@bitgo/sdk-coin-xrp 3.1.0 → 3.3.0

package/dist/src/lib/transaction.js

@@ -0,0 +1,371 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const xrpl = __importStar(require("xrpl"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const utils_1 = __importDefault(require("./utils"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const iface_1 = require("./iface");
+/**
+ * XRP transaction.
+ */
+class Transaction extends sdk_core_1.BaseTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+    }
+    get xrpTransaction() {
+        return this._xrpTransaction;
+    }
+    set xrpTransaction(tx) {
+        this._xrpTransaction = tx;
+    }
+    canSign(key) {
+        if (!utils_1.default.isValidPrivateKey(key.key)) {
+            return false;
+        }
+        return true;
+    }
+    toJson() {
+        if (!this._xrpTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        const txData = {
+            from: this._xrpTransaction.Account,
+            isMultiSig: this._isMultiSig,
+            transactionType: this._xrpTransaction.TransactionType,
+            id: this._id,
+            fee: this._xrpTransaction.Fee,
+            sequence: this._xrpTransaction.Sequence,
+            lastLedgerSequence: this._xrpTransaction.LastLedgerSequence,
+            flags: this._xrpTransaction.Flags,
+            signingPubKey: this._xrpTransaction.SigningPubKey,
+            signers: this._xrpTransaction.Signers,
+            txnSignature: this._xrpTransaction.TxnSignature,
+        };
+        if (this._xrpTransaction.SigningPubKey === '' && !lodash_1.default.isEmpty(this._xrpTransaction.Signers)) {
+            txData.isMultiSig = true;
+        }
+        if (this._xrpTransaction.SigningPubKey && utils_1.default.isValidPublicKey(this._xrpTransaction.SigningPubKey)) {
+            txData.isMultiSig = false;
+        }
+        switch (this._xrpTransaction.TransactionType) {
+            case iface_1.XrpTransactionType.Payment:
+                txData.destination = this._xrpTransaction.Destination;
+                txData.destinationTag = this._xrpTransaction.DestinationTag;
+                if (typeof this._xrpTransaction.Amount === 'string' ||
+                    utils_1.default.isIssuedCurrencyAmount(this._xrpTransaction.Amount)) {
+                    txData.amount = this._xrpTransaction.Amount;
+                }
+                else {
+                    throw new sdk_core_1.InvalidTransactionError('Invalid amount');
+                }
+                return txData;
+            case iface_1.XrpTransactionType.AccountSet:
+                txData.setFlag = this._xrpTransaction.SetFlag;
+                txData.messageKey = this._xrpTransaction.MessageKey;
+                return txData;
+            case iface_1.XrpTransactionType.SignerListSet:
+                txData.signerQuorum = this._xrpTransaction.SignerQuorum;
+                txData.signerEntries = this._xrpTransaction.SignerEntries;
+                return txData;
+            case iface_1.XrpTransactionType.TrustSet:
+                txData.amount = this._xrpTransaction.LimitAmount;
+                return txData;
+            default:
+                throw new sdk_core_1.InvalidTransactionError('Invalid transaction type');
+        }
+    }
+    getSignablePayload() {
+        if (!this._xrpTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        return lodash_1.default.omit(this._xrpTransaction, ['TxnSignature', 'Signers', 'SigningPubKey']);
+    }
+    sign(keyPair) {
+        if (!this._xrpTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        if (!this._xrpTransaction.Fee) {
+            throw new sdk_core_1.InvalidTransactionError('Missing fee');
+        }
+        if (!this._xrpTransaction.Sequence) {
+            throw new sdk_core_1.InvalidTransactionError('Missing sequence');
+        }
+        if (!this._xrpTransaction.Flags) {
+            throw new sdk_core_1.InvalidTransactionError('Missing flags');
+        }
+        if (lodash_1.default.isEmpty(keyPair)) {
+            return;
+        }
+        const keyPairs = keyPair instanceof Array ? keyPair : [keyPair];
+        for (const kp of keyPairs) {
+            const { pub, prv } = kp.getKeys();
+            if (!prv) {
+                throw new sdk_core_1.SigningError('Missing private key');
+            }
+            if (this._isMultiSig === false && this._xrpTransaction.TxnSignature) {
+                throw new sdk_core_1.SigningError('Transaction has already been signed');
+            }
+            const signablePayload = this.getSignablePayload();
+            const xrpWallet = new xrpl.Wallet(pub, prv);
+            const signedTx = xrpWallet.sign(signablePayload, this._isMultiSig);
+            const xrpSignedTx = xrpl.decode(signedTx.tx_blob);
+            xrpl.validate(xrpSignedTx);
+            if (this._isMultiSig === false) {
+                xrpWallet.verifyTransaction(signedTx.tx_blob);
+                this._xrpTransaction = xrpSignedTx;
+                this._id = signedTx.hash;
+            }
+            if (this._isMultiSig === true) {
+                if (!xrpSignedTx.Signers || !lodash_1.default.isArray(xrpSignedTx.Signers)) {
+                    throw new sdk_core_1.SigningError('Missing or invalid signers');
+                }
+                const sortedSigners = this.concatAndSortSigners(this._xrpTransaction.Signers || [], xrpSignedTx.Signers);
+                this._xrpTransaction = xrpSignedTx;
+                this._xrpTransaction.Signers = sortedSigners;
+                this._id = this.calculateIdFromRawTx(xrpl.encode(this._xrpTransaction));
+            }
+        }
+    }
+    /** @inheritdoc */
+    toBroadcastFormat() {
+        if (!this._xrpTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        return xrpl.encode(this._xrpTransaction);
+    }
+    explainTransaction() {
+        switch (this._xrpTransaction.TransactionType) {
+            case iface_1.XrpTransactionType.Payment:
+                return this.explainPaymentTransaction();
+            case iface_1.XrpTransactionType.AccountSet:
+                return this.explainAccountSetTransaction();
+            case iface_1.XrpTransactionType.SignerListSet:
+                return this.explainSignerListSetTransaction();
+            default:
+                throw new Error('Unsupported transaction type');
+        }
+    }
+    explainPaymentTransaction() {
+        const tx = this._xrpTransaction;
+        const address = utils_1.default.normalizeAddress({ address: tx.Destination, destinationTag: tx.DestinationTag });
+        const amount = lodash_1.default.isString(tx.Amount) ? tx.Amount : 0;
+        return {
+            displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee'],
+            id: this._id,
+            changeOutputs: [],
+            outputAmount: amount,
+            changeAmount: 0,
+            outputs: [
+                {
+                    address,
+                    amount,
+                },
+            ],
+            fee: {
+                fee: tx.Fee,
+                feeRate: undefined,
+            },
+        };
+    }
+    explainAccountSetTransaction() {
+        const tx = this._xrpTransaction;
+        return {
+            displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'accountSet'],
+            id: this._id,
+            changeOutputs: [],
+            outputAmount: 0,
+            changeAmount: 0,
+            outputs: [],
+            fee: {
+                fee: tx.Fee,
+                feeRate: undefined,
+            },
+            accountSet: {
+                messageKey: tx.MessageKey,
+                setFlag: tx.SetFlag,
+            },
+        };
+    }
+    explainSignerListSetTransaction() {
+        const tx = this._xrpTransaction;
+        return {
+            displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'signerListSet'],
+            id: this._id,
+            changeOutputs: [],
+            outputAmount: 0,
+            changeAmount: 0,
+            outputs: [],
+            fee: {
+                fee: tx.Fee,
+                feeRate: undefined,
+            },
+            signerListSet: {
+                signerQuorum: tx.SignerQuorum,
+                signerEntries: tx.SignerEntries,
+            },
+        };
+    }
+    calculateIdFromRawTx(rawTransaction) {
+        let id;
+        // hashes ids are different for signed and unsigned tx
+        // first we try to get the hash id as if it is signed, will throw if its not
+        try {
+            id = xrpl.hashes.hashSignedTx(rawTransaction);
+        }
+        catch (e) {
+            id = xrpl.hashes.hashTx(rawTransaction);
+        }
+        return id;
+    }
+    /**
+     * Set the transaction type.
+     *
+     * @param {TransactionType} transactionType The transaction type to be set.
+     */
+    setTransactionType(transactionType) {
+        this._type = transactionType;
+    }
+    setMultiSigValue(isMultiSig) {
+        this._isMultiSig = isMultiSig;
+    }
+    /**
+     * Sets this transaction payload
+     *
+     * @param rawTransaction
+     */
+    fromRawTransaction(rawTransaction) {
+        let txHex = rawTransaction;
+        if (!utils_1.default.isValidHex(rawTransaction)) {
+            try {
+                txHex = xrpl.encode(JSON.parse(rawTransaction));
+            }
+            catch (e) {
+                throw new sdk_core_1.InvalidTransactionError('Invalid transaction');
+            }
+        }
+        utils_1.default.validateRawTransaction(txHex);
+        this._xrpTransaction = xrpl.decode(txHex);
+        if (!iface_1.XrpTransactionType[this._xrpTransaction.TransactionType]) {
+            throw new sdk_core_1.InvalidTransactionError('Unsupported transaction type, got: ' + this._xrpTransaction.TransactionType);
+        }
+        if (this._xrpTransaction.SigningPubKey && this._xrpTransaction.SigningPubKey !== '') {
+            this._isMultiSig = false;
+        }
+        if (this._xrpTransaction.SigningPubKey === '' &&
+            this._xrpTransaction.Signers &&
+            this._xrpTransaction.Signers.length > 0) {
+            this._isMultiSig = true;
+        }
+        this._id = this.calculateIdFromRawTx(txHex);
+        switch (this._xrpTransaction.TransactionType) {
+            case iface_1.XrpTransactionType.SignerListSet:
+                this.setTransactionType(sdk_core_1.TransactionType.WalletInitialization);
+                break;
+            case iface_1.XrpTransactionType.AccountSet:
+                this.setTransactionType(sdk_core_1.TransactionType.AccountUpdate);
+                break;
+            case iface_1.XrpTransactionType.Payment:
+                if (utils_1.default.isIssuedCurrencyAmount(this._xrpTransaction.Amount)) {
+                    this.setTransactionType(sdk_core_1.TransactionType.SendToken);
+                }
+                else {
+                    this.setTransactionType(sdk_core_1.TransactionType.Send);
+                }
+                break;
+            case iface_1.XrpTransactionType.TrustSet:
+                this.setTransactionType(sdk_core_1.TransactionType.TrustLine);
+                break;
+        }
+        this.loadInputsAndOutputs();
+    }
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs() {
+        if (!this._xrpTransaction) {
+            return;
+        }
+        if (this._xrpTransaction.TransactionType === iface_1.XrpTransactionType.Payment) {
+            let value;
+            const { Account, Destination, Amount, DestinationTag } = this._xrpTransaction;
+            if (typeof Amount === 'string') {
+                value = Amount;
+            }
+            else {
+                value = Amount.value;
+            }
+            const coin = this._coinConfig.name;
+            this.inputs.push({
+                address: Account,
+                value,
+                coin,
+            });
+            this.outputs.push({
+                address: utils_1.default.normalizeAddress({ address: Destination, destinationTag: DestinationTag }),
+                value,
+                coin,
+            });
+        }
+    }
+    /**
+     * Groups and sorts the signers by account.
+     * @param {Signer[]}signers1 - The first set of signers.
+     * @param {Signer[]}signers2 - The second set of signers.
+     * @returns The grouped and sorted signers.
+     **/
+    concatAndSortSigners(signers1, signers2) {
+        return signers1
+            .concat(signers2)
+            .sort((signer1, signer2) => this.compareSignersByAccount(signer1.Signer.Account, signer2.Signer.Account));
+    }
+    /**
+     * If presented in binary form, the Signers array must be sorted based on
+     * the numeric value of the signer addresses, with the lowest value first.
+     * (If submitted as JSON, the submit_multisigned method handles this automatically.)
+     * https://xrpl.org/multi-signing.html.
+     *
+     * @param left - A Signer to compare with.
+     * @param right - A second Signer to compare with.
+     * @returns 1 if left \> right, 0 if left = right, -1 if left \< right, and null if left or right are NaN.
+     */
+    compareSignersByAccount(address1, address2) {
+        const addressBN1 = this.addressToBigNumber(address1);
+        const addressBN2 = this.addressToBigNumber(address2);
+        return addressBN1.comparedTo(addressBN2);
+    }
+    addressToBigNumber(address) {
+        const hex = Buffer.from(xrpl.decodeAccountID(address)).toString('hex');
+        const numberOfBitsInHex = 16;
+        return new bignumber_js_1.default(hex, numberOfBitsInHex);
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport * as xrpl from 'xrpl';\n\nimport {\n  BaseKey,\n  BaseTransaction,\n  TransactionExplanation as BaseTransactionExplanation,\n  InvalidTransactionError,\n  SigningError,\n  TransactionType,\n} from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport utils from './utils';\n\nimport BigNumber from 'bignumber.js';\nimport { Signer } from 'xrpl';\nimport {\n  AccountSetTransactionExplanation,\n  SignerListSetTransactionExplanation,\n  TransactionExplanation,\n  TxData,\n  XrpTransaction,\n  XrpTransactionType,\n} from './iface';\nimport { KeyPair } from './keyPair';\n\n/**\n * XRP transaction.\n */\nexport class Transaction extends BaseTransaction {\n  // XRP specific fields\n  protected _xrpTransaction: XrpTransaction;\n  protected _isMultiSig: boolean;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n  }\n\n  get xrpTransaction(): XrpTransaction {\n    return this._xrpTransaction;\n  }\n\n  set xrpTransaction(tx: XrpTransaction) {\n    this._xrpTransaction = tx;\n  }\n\n  canSign(key: BaseKey): boolean {\n    if (!utils.isValidPrivateKey(key.key)) {\n      return false;\n    }\n    return true;\n  }\n\n  toJson(): TxData {\n    if (!this._xrpTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n\n    const txData: TxData = {\n      from: this._xrpTransaction.Account,\n      isMultiSig: this._isMultiSig,\n      transactionType: this._xrpTransaction.TransactionType as XrpTransactionType,\n      id: this._id,\n      fee: this._xrpTransaction.Fee,\n      sequence: this._xrpTransaction.Sequence,\n      lastLedgerSequence: this._xrpTransaction.LastLedgerSequence,\n      flags: this._xrpTransaction.Flags as number,\n      signingPubKey: this._xrpTransaction.SigningPubKey,\n      signers: this._xrpTransaction.Signers,\n      txnSignature: this._xrpTransaction.TxnSignature,\n    };\n\n    if (this._xrpTransaction.SigningPubKey === '' && !_.isEmpty(this._xrpTransaction.Signers)) {\n      txData.isMultiSig = true;\n    }\n    if (this._xrpTransaction.SigningPubKey && utils.isValidPublicKey(this._xrpTransaction.SigningPubKey)) {\n      txData.isMultiSig = false;\n    }\n\n    switch (this._xrpTransaction.TransactionType) {\n      case XrpTransactionType.Payment:\n        txData.destination = this._xrpTransaction.Destination;\n        txData.destinationTag = this._xrpTransaction.DestinationTag;\n        if (\n          typeof this._xrpTransaction.Amount === 'string' ||\n          utils.isIssuedCurrencyAmount(this._xrpTransaction.Amount)\n        ) {\n          txData.amount = this._xrpTransaction.Amount;\n        } else {\n          throw new InvalidTransactionError('Invalid amount');\n        }\n        return txData;\n\n      case XrpTransactionType.AccountSet:\n        txData.setFlag = this._xrpTransaction.SetFlag;\n        txData.messageKey = this._xrpTransaction.MessageKey;\n        return txData;\n\n      case XrpTransactionType.SignerListSet:\n        txData.signerQuorum = this._xrpTransaction.SignerQuorum;\n        txData.signerEntries = this._xrpTransaction.SignerEntries;\n        return txData;\n\n      case XrpTransactionType.TrustSet:\n        txData.amount = this._xrpTransaction.LimitAmount;\n        return txData;\n\n      default:\n        throw new InvalidTransactionError('Invalid transaction type');\n    }\n  }\n\n  getSignablePayload(): XrpTransaction {\n    if (!this._xrpTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    return _.omit(this._xrpTransaction, ['TxnSignature', 'Signers', 'SigningPubKey']) as XrpTransaction;\n  }\n\n  sign(keyPair: KeyPair | KeyPair[]): void {\n    if (!this._xrpTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    if (!this._xrpTransaction.Fee) {\n      throw new InvalidTransactionError('Missing fee');\n    }\n    if (!this._xrpTransaction.Sequence) {\n      throw new InvalidTransactionError('Missing sequence');\n    }\n    if (!this._xrpTransaction.Flags) {\n      throw new InvalidTransactionError('Missing flags');\n    }\n    if (_.isEmpty(keyPair)) {\n      return;\n    }\n\n    const keyPairs = keyPair instanceof Array ? keyPair : [keyPair];\n    for (const kp of keyPairs) {\n      const { pub, prv } = kp.getKeys();\n      if (!prv) {\n        throw new SigningError('Missing private key');\n      }\n\n      if (this._isMultiSig === false && this._xrpTransaction.TxnSignature) {\n        throw new SigningError('Transaction has already been signed');\n      }\n      const signablePayload = this.getSignablePayload();\n\n      const xrpWallet = new xrpl.Wallet(pub, prv);\n      const signedTx = xrpWallet.sign(signablePayload, this._isMultiSig);\n      const xrpSignedTx = xrpl.decode(signedTx.tx_blob);\n      xrpl.validate(xrpSignedTx);\n\n      if (this._isMultiSig === false) {\n        xrpWallet.verifyTransaction(signedTx.tx_blob);\n        this._xrpTransaction = xrpSignedTx as unknown as XrpTransaction;\n        this._id = signedTx.hash;\n      }\n\n      if (this._isMultiSig === true) {\n        if (!xrpSignedTx.Signers || !_.isArray(xrpSignedTx.Signers)) {\n          throw new SigningError('Missing or invalid signers');\n        }\n        const sortedSigners = this.concatAndSortSigners(this._xrpTransaction.Signers || [], xrpSignedTx.Signers);\n        this._xrpTransaction = xrpSignedTx as unknown as XrpTransaction;\n        this._xrpTransaction.Signers = sortedSigners;\n        this._id = this.calculateIdFromRawTx(xrpl.encode(this._xrpTransaction));\n      }\n    }\n  }\n\n  /** @inheritdoc */\n  toBroadcastFormat(): string {\n    if (!this._xrpTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    return xrpl.encode(this._xrpTransaction);\n  }\n\n  explainTransaction(): TransactionExplanation {\n    switch (this._xrpTransaction.TransactionType) {\n      case XrpTransactionType.Payment:\n        return this.explainPaymentTransaction();\n      case XrpTransactionType.AccountSet:\n        return this.explainAccountSetTransaction();\n      case XrpTransactionType.SignerListSet:\n        return this.explainSignerListSetTransaction();\n      default:\n        throw new Error('Unsupported transaction type');\n    }\n  }\n\n  private explainPaymentTransaction(): BaseTransactionExplanation {\n    const tx = this._xrpTransaction as xrpl.Payment;\n    const address = utils.normalizeAddress({ address: tx.Destination, destinationTag: tx.DestinationTag });\n    const amount = _.isString(tx.Amount) ? tx.Amount : 0;\n\n    return {\n      displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee'],\n      id: this._id as string,\n      changeOutputs: [],\n      outputAmount: amount,\n      changeAmount: 0,\n      outputs: [\n        {\n          address,\n          amount,\n        },\n      ],\n      fee: {\n        fee: tx.Fee as string,\n        feeRate: undefined,\n      },\n    };\n  }\n\n  private explainAccountSetTransaction(): AccountSetTransactionExplanation {\n    const tx = this._xrpTransaction as xrpl.AccountSet;\n    return {\n      displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'accountSet'],\n      id: this._id as string,\n      changeOutputs: [],\n      outputAmount: 0,\n      changeAmount: 0,\n      outputs: [],\n      fee: {\n        fee: tx.Fee as string,\n        feeRate: undefined,\n      },\n      accountSet: {\n        messageKey: tx.MessageKey,\n        setFlag: tx.SetFlag as xrpl.AccountSetAsfFlags,\n      },\n    };\n  }\n\n  private explainSignerListSetTransaction(): SignerListSetTransactionExplanation {\n    const tx = this._xrpTransaction as xrpl.SignerListSet;\n    return {\n      displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'signerListSet'],\n      id: this._id as string,\n      changeOutputs: [],\n      outputAmount: 0,\n      changeAmount: 0,\n      outputs: [],\n      fee: {\n        fee: tx.Fee as string,\n        feeRate: undefined,\n      },\n      signerListSet: {\n        signerQuorum: tx.SignerQuorum,\n        signerEntries: tx.SignerEntries as xrpl.SignerEntry[],\n      },\n    };\n  }\n\n  private calculateIdFromRawTx(rawTransaction: string): string {\n    let id: string;\n    // hashes ids are different for signed and unsigned tx\n    // first we try to get the hash id as if it is signed, will throw if its not\n    try {\n      id = xrpl.hashes.hashSignedTx(rawTransaction);\n    } catch (e) {\n      id = xrpl.hashes.hashTx(rawTransaction);\n    }\n    return id;\n  }\n\n  /**\n   * Set the transaction type.\n   *\n   * @param {TransactionType} transactionType The transaction type to be set.\n   */\n  setTransactionType(transactionType: TransactionType): void {\n    this._type = transactionType;\n  }\n\n  setMultiSigValue(isMultiSig: boolean): void {\n    this._isMultiSig = isMultiSig;\n  }\n\n  /**\n   * Sets this transaction payload\n   *\n   * @param rawTransaction\n   */\n  fromRawTransaction(rawTransaction: string): void {\n    let txHex = rawTransaction;\n    if (!utils.isValidHex(rawTransaction)) {\n      try {\n        txHex = xrpl.encode(JSON.parse(rawTransaction));\n      } catch (e) {\n        throw new InvalidTransactionError('Invalid transaction');\n      }\n    }\n    utils.validateRawTransaction(txHex);\n\n    this._xrpTransaction = xrpl.decode(txHex) as unknown as XrpTransaction;\n    if (!XrpTransactionType[this._xrpTransaction.TransactionType]) {\n      throw new InvalidTransactionError('Unsupported transaction type, got: ' + this._xrpTransaction.TransactionType);\n    }\n    if (this._xrpTransaction.SigningPubKey && this._xrpTransaction.SigningPubKey !== '') {\n      this._isMultiSig = false;\n    }\n    if (\n      this._xrpTransaction.SigningPubKey === '' &&\n      this._xrpTransaction.Signers &&\n      this._xrpTransaction.Signers.length > 0\n    ) {\n      this._isMultiSig = true;\n    }\n    this._id = this.calculateIdFromRawTx(txHex);\n\n    switch (this._xrpTransaction.TransactionType) {\n      case XrpTransactionType.SignerListSet:\n        this.setTransactionType(TransactionType.WalletInitialization);\n        break;\n      case XrpTransactionType.AccountSet:\n        this.setTransactionType(TransactionType.AccountUpdate);\n        break;\n      case XrpTransactionType.Payment:\n        if (utils.isIssuedCurrencyAmount(this._xrpTransaction.Amount)) {\n          this.setTransactionType(TransactionType.SendToken);\n        } else {\n          this.setTransactionType(TransactionType.Send);\n        }\n        break;\n      case XrpTransactionType.TrustSet:\n        this.setTransactionType(TransactionType.TrustLine);\n        break;\n    }\n    this.loadInputsAndOutputs();\n  }\n\n  /**\n   * Load the input and output data on this transaction.\n   */\n  loadInputsAndOutputs(): void {\n    if (!this._xrpTransaction) {\n      return;\n    }\n    if (this._xrpTransaction.TransactionType === XrpTransactionType.Payment) {\n      let value: string;\n      const { Account, Destination, Amount, DestinationTag } = this._xrpTransaction;\n      if (typeof Amount === 'string') {\n        value = Amount;\n      } else {\n        value = Amount.value;\n      }\n      const coin = this._coinConfig.name;\n      this.inputs.push({\n        address: Account,\n        value,\n        coin,\n      });\n      this.outputs.push({\n        address: utils.normalizeAddress({ address: Destination, destinationTag: DestinationTag }),\n        value,\n        coin,\n      });\n    }\n  }\n\n  /**\n   * Groups and sorts the signers by account.\n   * @param {Signer[]}signers1 - The first set of signers.\n   * @param {Signer[]}signers2 - The second set of signers.\n   * @returns The grouped and sorted signers.\n   **/\n  private concatAndSortSigners(signers1: Signer[], signers2: Signer[]): Signer[] {\n    return signers1\n      .concat(signers2)\n      .sort((signer1, signer2) => this.compareSignersByAccount(signer1.Signer.Account, signer2.Signer.Account));\n  }\n\n  /**\n   * If presented in binary form, the Signers array must be sorted based on\n   * the numeric value of the signer addresses, with the lowest value first.\n   * (If submitted as JSON, the submit_multisigned method handles this automatically.)\n   * https://xrpl.org/multi-signing.html.\n   *\n   * @param left - A Signer to compare with.\n   * @param right - A second Signer to compare with.\n   * @returns 1 if left \\> right, 0 if left = right, -1 if left \\< right, and null if left or right are NaN.\n   */\n  private compareSignersByAccount(address1: string, address2: string): number {\n    const addressBN1 = this.addressToBigNumber(address1);\n    const addressBN2 = this.addressToBigNumber(address2);\n    return addressBN1.comparedTo(addressBN2);\n  }\n\n  private addressToBigNumber(address: string): BigNumber {\n    const hex = Buffer.from(xrpl.decodeAccountID(address)).toString('hex');\n    const numberOfBitsInHex = 16;\n    return new BigNumber(hex, numberOfBitsInHex);\n  }\n}\n"]}

package/dist/src/lib/transactionBuilder.d.ts

@@ -0,0 +1,72 @@
+import { BaseAddress, BaseKey, BaseTransaction, BaseTransactionBuilder, TransactionType } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import BigNumber from 'bignumber.js';
+import { Signer } from 'xrpl/dist/npm/models/common';
+import { XrpTransaction } from './iface';
+import { KeyPair } from './keyPair';
+import { Transaction } from './transaction';
+/**
+ * XRP transaction builder.
+ */
+export declare abstract class TransactionBuilder extends BaseTransactionBuilder {
+    protected _transaction: Transaction;
+    protected _sender: string;
+    protected _fee?: string;
+    protected _sequence?: number;
+    protected _lastLedgerSequence?: number;
+    protected _flags?: number;
+    protected _signingPubKey?: string;
+    protected _signers: Signer[];
+    protected _txnSignature?: string;
+    protected _specificFields: XrpTransaction;
+    protected _isMultiSig?: boolean;
+    protected _keyPairs: KeyPair[];
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * The transaction type.
+     */
+    protected abstract get transactionType(): TransactionType;
+    /**
+     * Set the transaction signature type to multi sig.
+     **/
+    setMultiSig(): TransactionBuilder;
+    /**
+     * Set the transaction signature type to single sig.
+     **/
+    setSingleSig(): TransactionBuilder;
+    /**
+     * Sets the sender of this transaction.
+     *
+     * @param {string} address the account that is sending this transaction
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    sender(address: string): TransactionBuilder;
+    sequence(sequence: number): TransactionBuilder;
+    fee(fee: string): TransactionBuilder;
+    flags(flags: number): TransactionBuilder;
+    lastLedgerSequence(lastLedgerSequence: number): TransactionBuilder;
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     */
+    initBuilder(tx: Transaction): void;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): BaseTransaction;
+    /** @inheritdoc */
+    protected signImplementation(key: BaseKey): Transaction;
+    private checkDuplicatedKeys;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    private buildXrpTransaction;
+    validateKey(key: BaseKey): void;
+    validateIsMultiSig(): void;
+    /** @inheritdoc */
+    validateTransaction(): void;
+    validateAddress(address: BaseAddress): void;
+    validateValue(value: BigNumber): void;
+    validateRawTransaction(rawTransaction: string): void;
+    protected get transaction(): Transaction;
+    protected set transaction(transaction: Transaction);
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

package/dist/src/lib/transactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,OAAO,EACP,eAAe,EACf,sBAAsB,EAGtB,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,SAAS,MAAM,cAAc,CAAC;AAGrC,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C;;GAEG;AACH,8BAAsB,kBAAmB,SAAQ,sBAAsB;IACrE,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC;IACpC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACvC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAK;IAC9B,SAAS,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC7B,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IACjC,SAAS,CAAC,eAAe,EAAE,cAAc,CAAC;IAE1C,SAAS,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAEhC,SAAS,CAAC,SAAS,EAAE,OAAO,EAAE,CAAC;gBAEnB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAO7C;;OAEG;IACH,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC;IAE1D;;QAEI;IACJ,WAAW,IAAI,kBAAkB;IAKjC;;QAEI;IACJ,YAAY,IAAI,kBAAkB;IAKlC;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB;IAM3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB;IAQ9C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAYpC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB;IAQxC,kBAAkB,CAAC,kBAAkB,EAAE,MAAM,GAAG,kBAAkB;IAQlE;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA0BlC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe;IAQrE,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW;IAevD,OAAO,CAAC,mBAAmB;IAiB3B,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAY3D,OAAO,CAAC,mBAAmB;IA0B3B,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAa/B,kBAAkB,IAAI,IAAI;IAM1B,kBAAkB;IAClB,mBAAmB,IAAI,IAAI;IAY3B,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAM3C,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAMrC,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAIpD,SAAS,KAAK,WAAW,IAAI,WAAW,CAEvC;IAED,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,WAAW,EAEjD;CACF"}