node_modules/digitalbits-base/src/transaction.js

  1. import {xdr, hash} from "./index";
  3. import {StrKey} from "./strkey";
  4. import {Operation} from "./operation";
  5. import {Network} from "./network";
  6. import {Memo} from "./memo";
  7. import map from "lodash/map";
  8. import each from "lodash/each";
  9. import isString from 'lodash/isString';
  10. import crypto from "crypto";
  12. let MIN_LEDGER   = 0;
  13. let MAX_LEDGER   = 0xFFFFFFFF; // max uint32
  15. /**
  16.  * A new Transaction object is created from a transaction envelope or via {@link TransactionBuilder}.
  17.  * Once a Transaction has been created from an envelope, its attributes and operations
  18.  * should not be changed. You should only add signers (using {@link Transaction#sign}) to a Transaction object before
  19.  * submitting to the network or forwarding on to additional signers.
  20.  * @constructor
  21.  * @param {string|xdr.TransactionEnvelope} envelope - The transaction envelope object or base64 encoded string.
  22.  */
  23. export class Transaction {
  24.   constructor(envelope) {
  25.     if (typeof envelope === "string") {
  26.       let buffer = new Buffer(envelope, "base64");
  27.       envelope = xdr.TransactionEnvelope.fromXDR(buffer);
  28.     }
  29.     // since this transaction is immutable, save the tx
  30.     this.tx       = envelope.tx();
  31.     this.source   = StrKey.encodeEd25519PublicKey(envelope.tx().sourceAccount().ed25519());
  32.     this.fee      = this.tx.fee();
  33.     this._memo    = this.tx.memo();
  34.     this.sequence = this.tx.seqNum().toString();
  36.     let timeBounds = this.tx.timeBounds();
  37.     if (timeBounds) {
  38.       this.timeBounds = {
  39.         minTime: timeBounds.minTime().toString(),
  40.         maxTime: timeBounds.maxTime().toString()
  41.       };
  42.     }
  44.     let operations  = this.tx.operations() || [];
  45.     this.operations = map(operations, op => {
  46.       return Operation.fromXDRObject(op);
  47.     });
  49.     let signatures = envelope.signatures() || [];
  50.     this.signatures = map(signatures, s => s);
  51.   }
  53.   get memo() {
  54.     return Memo.fromXDRObject(this._memo);
  55.   }
  57.   set memo(value) {
  58.     throw new Error("Transaction is immutable");
  59.   }
  61.   /**
  62.    * Signs the transaction with the given {@link Keypair}.
  63.    * @param {...Keypair} keypairs Keypairs of signers
  64.    * @returns {void}
  65.    */
  66.   sign(...keypairs) {
  67.     let txHash = this.hash();
  68.     let newSigs = each(keypairs, kp => {
  69.       let sig = kp.signDecorated(txHash);
  70.       this.signatures.push(sig);
  71.     });
  72.   }
  74.   /**
  75.    * Add `hashX` signer preimage as signature.
  76.    * @param {Buffer|String} preimage Preimage of hash used as signer
  77.    * @returns {void}
  78.    */
  79.   signHashX(preimage) {
  80.     if (isString(preimage)) {
  81.       preimage = Buffer.from(preimage, "hex");
  82.     }
  84.     if (preimage.length > 64) {
  85.       throw new Error('preimage cannnot be longer than 64 bytes');
  86.     }
  88.     let signature = preimage;
  89.     let hash = crypto.createHash('sha256').update(preimage).digest();
  90.     let hint = hash.slice(hash.length - 4);
  91.     this.signatures.push(new xdr.DecoratedSignature({hint, signature}));
  92.   }
  94.   /**
  95.    * Returns a hash for this transaction, suitable for signing.
  96.    * @returns {Buffer}
  97.    */
  98.   hash() {
  99.     return hash(this.signatureBase());
  100.   }
  102.   /**
  103.    * Returns the "signature base" of this transaction, which is the value
  104.    * that, when hashed, should be signed to create a signature that
  105.    * validators on the DigitalBits Network will accept.
  106.    *
  107.    * It is composed of a 4 prefix bytes followed by the xdr-encoded form
  108.    * of this transaction.
  109.    * @returns {Buffer}
  110.    */
  111.   signatureBase() {
  112.     if (Network.current() === null) {
  113.       throw new Error("No network selected. Use `Network.use`, `Network.usePublicNetwork` or `Network.useTestNetwork` helper methods to select network.");
  114.     }
  116.     return Buffer.concat([
  117.       Network.current().networkId(),
  118.       xdr.EnvelopeType.envelopeTypeTx().toXDR(),
  119.       this.tx.toXDR()
  120.     ]);
  121.   }
  123.   /**
  124.    * To envelope returns a xdr.TransactionEnvelope which can be submitted to the network.
  125.    * @returns {xdr.TransactionEnvelope}
  126.    */
  127.   toEnvelope() {
  128.     let tx = this.tx;
  129.     let signatures = this.signatures;
  130.     let envelope = new xdr.TransactionEnvelope({tx, signatures});
  132.     return envelope;
  133.   }
  134. }