@bitgo/sdk-coin-sui 1.7.2 → 2.0.1

package/dist/src/lib/transferBuilder.js

@@ -1,15 +1,179 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransferBuilder = void 0;
 const transactionBuilder_1 = require("./transactionBuilder");
 const sdk_core_1 = require("@bitgo/sdk-core");
+const iface_1 = require("./iface");
+const transferTransaction_1 = require("./transferTransaction");
+const utils_1 = __importDefault(require("./utils"));
+const assert_1 = __importDefault(require("assert"));
 class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
+        this._transaction = new transferTransaction_1.TransferTransaction(_coinConfig);
     }
     get transactionType() {
         return sdk_core_1.TransactionType.Send;
     }
+    payTx(payTx) {
+        this.validateTxPay(payTx);
+        this._payTx = payTx;
+        return this;
+    }
+    validateTxPay(payTx) {
+        if (!payTx.hasOwnProperty('coins')) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid payTx, missing coins`);
+        }
+        if (!payTx.hasOwnProperty('recipients')) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid payTx, missing recipients`);
+        }
+        if (!payTx.hasOwnProperty('amounts')) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid payTx, missing amounts`);
+        }
+        if (this._type !== iface_1.SuiTransactionType.PayAllSui && payTx.recipients.length !== payTx.amounts.length) {
+            throw new sdk_core_1.BuildTransactionError(`recipients length ${payTx.recipients.length} must equal to amounts length ${payTx.amounts.length}`);
+        }
+        if (!utils_1.default.isValidAmounts(payTx.amounts)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing amounts, got: ' + payTx.amounts);
+        }
+        for (const coin of payTx.coins) {
+            this.validateSuiObjectRef(coin, 'payTx.coin');
+        }
+        for (const recipient of payTx.recipients) {
+            utils_1.default.validateAddress(recipient, 'payTx.recipient');
+        }
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        if (!transaction.suiTransaction) {
+            return;
+        }
+        this.validateTransactionFields();
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = new transferTransaction_1.TransferTransaction(this._coinConfig);
+        this.validateRawTransaction(rawTransaction);
+        tx.fromRawTransaction(rawTransaction);
+        this.initBuilder(tx);
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        this.transaction.setSuiTransaction(this.buildSuiTransaction());
+        this.transaction.transactionType(this.transactionType);
+        if (this._signer) {
+            this.transaction.sign(this._signer);
+        }
+        this._signatures.forEach((signature) => {
+            this.transaction.addSignature(signature.publicKey, signature.signature);
+        });
+        this.transaction.loadInputsAndOutputs();
+        return this.transaction;
+    }
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     */
+    initBuilder(tx) {
+        this._transaction = tx;
+        if (tx.signature && tx.signature.length > 0) {
+            this._signatures = [tx.suiSignature];
+        }
+        const txData = tx.toJson();
+        this.gasBudget(txData.gasBudget);
+        this.sender(txData.sender);
+        this.gasPayment(txData.gasPayment);
+        let payTx;
+        let txDetails = txData.kind.Single;
+        if (txDetails.hasOwnProperty('Pay')) {
+            this.type(iface_1.SuiTransactionType.Pay);
+            txDetails = txDetails;
+            payTx = {
+                coins: txDetails.Pay.coins,
+                recipients: txDetails.Pay.recipients,
+                amounts: txDetails.Pay.amounts,
+            };
+        }
+        else if (txDetails.hasOwnProperty('PaySui')) {
+            this.type(iface_1.SuiTransactionType.PaySui);
+            txDetails = txDetails;
+            payTx = {
+                coins: txDetails.PaySui.coins,
+                recipients: txDetails.PaySui.recipients,
+                amounts: txDetails.PaySui.amounts,
+            };
+        }
+        else if (txDetails.hasOwnProperty('PayAllSui')) {
+            this.type(iface_1.SuiTransactionType.PayAllSui);
+            txDetails = txDetails;
+            payTx = {
+                coins: txDetails.PayAllSui.coins,
+                recipients: [txDetails.PayAllSui.recipient],
+                amounts: [], // PayAllSui deserialization doesn't return the amount
+            };
+        }
+        else {
+            throw new Error('Transaction type not supported: ' + txDetails);
+        }
+        this.payTx(payTx);
+    }
+    /**
+     * Validates all fields are defined
+     */
+    validateTransactionFields() {
+        assert_1.default(this._type, new sdk_core_1.BuildTransactionError('type is required before building'));
+        assert_1.default(this._sender, new sdk_core_1.BuildTransactionError('sender is required before building'));
+        assert_1.default(this._payTx, new sdk_core_1.BuildTransactionError('payTx is required before building'));
+        assert_1.default(this._gasBudget, new sdk_core_1.BuildTransactionError('gasBudget is required before building'));
+        if (this._type === iface_1.SuiTransactionType.Pay) {
+            assert_1.default(this._gasPayment, new sdk_core_1.BuildTransactionError('gasPayment is required for type Pay before building'));
+            const coinIds = this._payTx.coins.map((coin) => coin.objectId);
+            if (coinIds.includes(this._gasPayment.objectId) && this._type === iface_1.SuiTransactionType.Pay) {
+                throw new sdk_core_1.BuildTransactionError(`Invalid gas payment ${this._gasPayment.objectId}: cannot be one of the inputCoins`);
+            }
+        }
+    }
+    // Reorder input coins so the first coin is the gas payment
+    reorderInputCoins() {
+        const coinIds = this._payTx.coins.map((coin) => coin.objectId);
+        const inputCoins = [];
+        inputCoins.push(...this._payTx.coins);
+        if (!coinIds.includes(this._gasPayment.objectId)) {
+            inputCoins.unshift(this._gasPayment);
+        }
+        else {
+            const gasPaymentIndex = inputCoins.findIndex((coin) => coin.objectId === this._gasPayment.objectId);
+            inputCoins[gasPaymentIndex] = inputCoins[0];
+            inputCoins[0] = this._gasPayment;
+        }
+        return inputCoins;
+    }
+    buildSuiTransaction() {
+        this.validateTransactionFields();
+        let payTx;
+        if (this._type === iface_1.SuiTransactionType.PaySui || this._type === iface_1.SuiTransactionType.PayAllSui) {
+            if (!this._gasPayment) {
+                this._gasPayment = this._payTx.coins[0];
+            }
+            else {
+                const inputCoins = this.reorderInputCoins();
+                payTx = { coins: inputCoins, recipients: this._payTx.recipients, amounts: this._payTx.amounts };
+            }
+        }
+        return {
+            type: this._type,
+            sender: this._sender,
+            tx: payTx !== null && payTx !== void 0 ? payTx : this._payTx,
+            gasBudget: this._gasBudget,
+            gasPrice: this._gasPrice,
+            gasPayment: this._gasPayment,
+        };
+    }
 }
 exports.TransferBuilder = TransferBuilder;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJCdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90cmFuc2ZlckJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkRBQTBEO0FBRTFELDhDQUFrRDtBQUVsRCxNQUFhLGVBQWdCLFNBQVEsdUNBQWtCO0lBQ3JELFlBQVksV0FBaUM7UUFDM0MsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxJQUFjLGVBQWU7UUFDM0IsT0FBTywwQkFBZSxDQUFDLElBQUksQ0FBQztJQUM5QixDQUFDO0NBQ0Y7QUFSRCwwQ0FRQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRyYW5zYWN0aW9uQnVpbGRlciB9IGZyb20gJy4vdHJhbnNhY3Rpb25CdWlsZGVyJztcbmltcG9ydCB7IEJhc2VDb2luIGFzIENvaW5Db25maWcgfSBmcm9tICdAYml0Z28vc3RhdGljcyc7XG5pbXBvcnQgeyBUcmFuc2FjdGlvblR5cGUgfSBmcm9tICdAYml0Z28vc2RrLWNvcmUnO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNmZXJCdWlsZGVyIGV4dGVuZHMgVHJhbnNhY3Rpb25CdWlsZGVyIHtcbiAgY29uc3RydWN0b3IoX2NvaW5Db25maWc6IFJlYWRvbmx5PENvaW5Db25maWc+KSB7XG4gICAgc3VwZXIoX2NvaW5Db25maWcpO1xuICB9XG5cbiAgcHJvdGVjdGVkIGdldCB0cmFuc2FjdGlvblR5cGUoKTogVHJhbnNhY3Rpb25UeXBlIHtcbiAgICByZXR1cm4gVHJhbnNhY3Rpb25UeXBlLlNlbmQ7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferBuilder.js","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionBuilder } from './transactionBuilder';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { BuildTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport {\n  PayAllSuiTxDetails,\n  PaySuiTxDetails,\n  PayTx,\n  PayTxDetails,\n  SuiObjectRef,\n  SuiTransaction,\n  SuiTransactionType,\n  TxDetails,\n} from './iface';\nimport { Transaction } from './transaction';\nimport { TransferTransaction } from './transferTransaction';\nimport utils from './utils';\nimport assert from 'assert';\n\nexport class TransferBuilder extends TransactionBuilder<PayTx> {\n  protected _payTx: PayTx;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new TransferTransaction(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Send;\n  }\n\n  payTx(payTx: PayTx): this {\n    this.validateTxPay(payTx);\n    this._payTx = payTx;\n    return this;\n  }\n\n  validateTxPay(payTx: PayTx): void {\n    if (!payTx.hasOwnProperty('coins')) {\n      throw new BuildTransactionError(`Invalid payTx, missing coins`);\n    }\n    if (!payTx.hasOwnProperty('recipients')) {\n      throw new BuildTransactionError(`Invalid payTx, missing recipients`);\n    }\n    if (!payTx.hasOwnProperty('amounts')) {\n      throw new BuildTransactionError(`Invalid payTx, missing amounts`);\n    }\n\n    if (this._type !== SuiTransactionType.PayAllSui && payTx.recipients.length !== payTx.amounts.length) {\n      throw new BuildTransactionError(\n        `recipients length ${payTx.recipients.length} must equal to amounts length ${payTx.amounts.length}`\n      );\n    }\n    if (!utils.isValidAmounts(payTx.amounts)) {\n      throw new BuildTransactionError('Invalid or missing amounts, got: ' + payTx.amounts);\n    }\n\n    for (const coin of payTx.coins) {\n      this.validateSuiObjectRef(coin, 'payTx.coin');\n    }\n\n    for (const recipient of payTx.recipients) {\n      utils.validateAddress(recipient, 'payTx.recipient');\n    }\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction: TransferTransaction): void {\n    if (!transaction.suiTransaction) {\n      return;\n    }\n    this.validateTransactionFields();\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction<PayTx> {\n    const tx = new TransferTransaction(this._coinConfig);\n    this.validateRawTransaction(rawTransaction);\n    tx.fromRawTransaction(rawTransaction);\n    this.initBuilder(tx);\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction<PayTx>> {\n    this.transaction.setSuiTransaction(this.buildSuiTransaction());\n    this.transaction.transactionType(this.transactionType);\n\n    if (this._signer) {\n      this.transaction.sign(this._signer);\n    }\n\n    this._signatures.forEach((signature) => {\n      this.transaction.addSignature(signature.publicKey, signature.signature);\n    });\n\n    this.transaction.loadInputsAndOutputs();\n    return this.transaction;\n  }\n\n  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx the transaction data\n   */\n  initBuilder(tx: TransferTransaction): void {\n    this._transaction = tx;\n\n    if (tx.signature && tx.signature.length > 0) {\n      this._signatures = [tx.suiSignature];\n    }\n\n    const txData = tx.toJson();\n    this.gasBudget(txData.gasBudget);\n    this.sender(txData.sender);\n    this.gasPayment(txData.gasPayment);\n\n    let payTx;\n    let txDetails: TxDetails = txData.kind.Single;\n    if (txDetails.hasOwnProperty('Pay')) {\n      this.type(SuiTransactionType.Pay);\n      txDetails = txDetails as PayTxDetails;\n      payTx = {\n        coins: txDetails.Pay.coins,\n        recipients: txDetails.Pay.recipients,\n        amounts: txDetails.Pay.amounts,\n      };\n    } else if (txDetails.hasOwnProperty('PaySui')) {\n      this.type(SuiTransactionType.PaySui);\n      txDetails = txDetails as PaySuiTxDetails;\n      payTx = {\n        coins: txDetails.PaySui.coins,\n        recipients: txDetails.PaySui.recipients,\n        amounts: txDetails.PaySui.amounts,\n      };\n    } else if (txDetails.hasOwnProperty('PayAllSui')) {\n      this.type(SuiTransactionType.PayAllSui);\n      txDetails = txDetails as PayAllSuiTxDetails;\n      payTx = {\n        coins: txDetails.PayAllSui.coins,\n        recipients: [txDetails.PayAllSui.recipient],\n        amounts: [], // PayAllSui deserialization doesn't return the amount\n      };\n    } else {\n      throw new Error('Transaction type not supported: ' + txDetails);\n    }\n    this.payTx(payTx);\n  }\n\n  /**\n   * Validates all fields are defined\n   */\n  private validateTransactionFields(): void {\n    assert(this._type, new BuildTransactionError('type is required before building'));\n    assert(this._sender, new BuildTransactionError('sender is required before building'));\n    assert(this._payTx, new BuildTransactionError('payTx is required before building'));\n    assert(this._gasBudget, new BuildTransactionError('gasBudget is required before building'));\n\n    if (this._type === SuiTransactionType.Pay) {\n      assert(this._gasPayment, new BuildTransactionError('gasPayment is required for type Pay before building'));\n\n      const coinIds = this._payTx.coins.map((coin) => coin.objectId);\n      if (coinIds.includes(this._gasPayment.objectId) && this._type === SuiTransactionType.Pay) {\n        throw new BuildTransactionError(\n          `Invalid gas payment ${this._gasPayment.objectId}: cannot be one of the inputCoins`\n        );\n      }\n    }\n  }\n\n  // Reorder input coins so the first coin is the gas payment\n  reorderInputCoins(): SuiObjectRef[] {\n    const coinIds = this._payTx.coins.map((coin) => coin.objectId);\n    const inputCoins: SuiObjectRef[] = [];\n    inputCoins.push(...this._payTx.coins);\n    if (!coinIds.includes(this._gasPayment.objectId)) {\n      inputCoins.unshift(this._gasPayment);\n    } else {\n      const gasPaymentIndex = inputCoins.findIndex((coin) => coin.objectId === this._gasPayment.objectId);\n      inputCoins[gasPaymentIndex] = inputCoins[0];\n      inputCoins[0] = this._gasPayment;\n    }\n\n    return inputCoins;\n  }\n\n  protected buildSuiTransaction(): SuiTransaction<PayTx> {\n    this.validateTransactionFields();\n\n    let payTx;\n    if (this._type === SuiTransactionType.PaySui || this._type === SuiTransactionType.PayAllSui) {\n      if (!this._gasPayment) {\n        this._gasPayment = this._payTx.coins[0];\n      } else {\n        const inputCoins = this.reorderInputCoins();\n        payTx = { coins: inputCoins, recipients: this._payTx.recipients, amounts: this._payTx.amounts };\n      }\n    }\n\n    return {\n      type: this._type,\n      sender: this._sender,\n      tx: payTx ?? this._payTx,\n      gasBudget: this._gasBudget,\n      gasPrice: this._gasPrice,\n      gasPayment: this._gasPayment,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import { BaseKey, PublicKey as BasePublicKey, Signature, TransactionType } from '@bitgo/sdk-core';
+import { PayTx, SuiObjectRef, SuiTransaction, TransactionExplanation, TxData } from './iface';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { Transaction } from './transaction';
+export declare class TransferTransaction extends Transaction<PayTx> {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    get suiTransaction(): SuiTransaction<PayTx>;
+    setSuiTransaction(tx: SuiTransaction<PayTx>): void;
+    /** @inheritDoc **/
+    get id(): string;
+    addSignature(publicKey: BasePublicKey, signature: Buffer): void;
+    get suiSignature(): Signature;
+    getInputCoins(): SuiObjectRef[];
+    /** @inheritdoc */
+    canSign(key: BaseKey): boolean;
+    /** @inheritdoc */
+    toBroadcastFormat(): string;
+    /** @inheritdoc */
+    toJson(): TxData;
+    /** @inheritDoc */
+    explainTransaction(): TransactionExplanation;
+    /**
+     * Set the transaction type.
+     *
+     * @param {TransactionType} transactionType The transaction type to be set.
+     */
+    transactionType(transactionType: TransactionType): void;
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs(): void;
+    /**
+     * Sets this transaction payload
+     *
+     * @param {string} rawTransaction
+     */
+    fromRawTransaction(rawTransaction: string): void;
+    /**
+     * Helper function for serialize() to get the correct txData with transaction type
+     *
+     * @return {TxData}
+     */
+    getTxData(): TxData;
+    /**
+     * Returns a complete explanation for a transfer transaction
+     * @param {TxData} json The transaction data in json format
+     * @param {TransactionExplanation} explanationResult The transaction explanation to be completed
+     * @returns {TransactionExplanation}
+     */
+    explainTransferTransaction(json: TxData, explanationResult: TransactionExplanation): TransactionExplanation;
+}
+//# sourceMappingURL=transferTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transferTransaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transferTransaction.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,OAAO,EAGP,SAAS,IAAI,aAAa,EAC1B,SAAS,EAET,eAAe,EAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,EACL,YAAY,EACZ,cAAc,EAEd,sBAAsB,EACtB,MAAM,EAEP,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,qBAAa,mBAAoB,SAAQ,WAAW,CAAC,KAAK,CAAC;gBAC7C,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,IAAI,cAAc,IAAI,cAAc,CAAC,KAAK,CAAC,CAE1C;IAED,iBAAiB,CAAC,EAAE,EAAE,cAAc,CAAC,KAAK,CAAC,GAAG,IAAI;IAIlD,mBAAmB;IACnB,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAM/D,IAAI,YAAY,IAAI,SAAS,CAE5B;IAED,aAAa,IAAI,YAAY,EAAE;IAI/B,kBAAkB;IAClB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAI9B,kBAAkB;IAClB,iBAAiB,IAAI,MAAM;IAO3B,kBAAkB;IAClB,MAAM,IAAI,MAAM;IAiDhB,kBAAkB;IAClB,kBAAkB,IAAI,sBAAsB;IAwB5C;;;;OAIG;IACH,eAAe,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAIvD;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAgC5B;;;;OAIG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAWhD;;;;OAIG;IACI,SAAS,IAAI,MAAM;IA+C1B;;;;;OAKG;IACH,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,sBAAsB,GAAG,sBAAsB;CAgB5G"}

package/dist/src/lib/transferTransaction.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferTransaction = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const iface_1 = require("./iface");
+const utils_1 = __importDefault(require("./utils"));
+const constants_1 = require("./constants");
+const transaction_1 = require("./transaction");
+class TransferTransaction extends transaction_1.Transaction {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get suiTransaction() {
+        return this._suiTransaction;
+    }
+    setSuiTransaction(tx) {
+        this._suiTransaction = tx;
+    }
+    /** @inheritDoc **/
+    get id() {
+        return this._id || constants_1.UNAVAILABLE_TEXT;
+    }
+    addSignature(publicKey, signature) {
+        this._signatures.push(signature.toString('hex'));
+        this._signature = { publicKey, signature };
+        this.serialize();
+    }
+    get suiSignature() {
+        return this._signature;
+    }
+    getInputCoins() {
+        return this.suiTransaction.tx.coins;
+    }
+    /** @inheritdoc */
+    canSign(key) {
+        return true;
+    }
+    /** @inheritdoc */
+    toBroadcastFormat() {
+        if (!this._suiTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        return this.serialize();
+    }
+    /** @inheritdoc */
+    toJson() {
+        if (!this._suiTransaction) {
+            throw new sdk_core_1.ParseTransactionError('Empty transaction');
+        }
+        const tx = this._suiTransaction;
+        let txDetails;
+        switch (tx.type) {
+            case iface_1.SuiTransactionType.Pay:
+                txDetails = {
+                    Pay: {
+                        coins: tx.tx.coins,
+                        recipients: tx.tx.recipients,
+                        amounts: tx.tx.amounts,
+                    },
+                };
+                break;
+            case iface_1.SuiTransactionType.PaySui:
+                txDetails = {
+                    PaySui: {
+                        coins: tx.tx.coins,
+                        recipients: tx.tx.recipients,
+                        amounts: tx.tx.amounts,
+                    },
+                };
+                break;
+            case iface_1.SuiTransactionType.PayAllSui:
+                txDetails = {
+                    PayAllSui: {
+                        coins: tx.tx.coins,
+                        recipient: tx.tx.recipients[0],
+                    },
+                };
+                break;
+            default:
+                throw new sdk_core_1.InvalidTransactionError('SuiTransactionType not supported');
+        }
+        return {
+            id: this._id,
+            kind: { Single: txDetails },
+            sender: tx.sender,
+            gasPayment: tx.gasPayment,
+            gasBudget: tx.gasBudget,
+            gasPrice: constants_1.SUI_GAS_PRICE,
+        };
+    }
+    /** @inheritDoc */
+    explainTransaction() {
+        const result = this.toJson();
+        const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'];
+        const outputs = [];
+        const explanationResult = {
+            displayOrder,
+            id: this.id,
+            outputs,
+            outputAmount: '0',
+            changeOutputs: [],
+            changeAmount: '0',
+            fee: { fee: this.suiTransaction.gasBudget.toString() },
+            type: this.type,
+        };
+        switch (this.type) {
+            case sdk_core_1.TransactionType.Send:
+                return this.explainTransferTransaction(result, explanationResult);
+            default:
+                throw new sdk_core_1.InvalidTransactionError('Transaction type not supported');
+        }
+    }
+    /**
+     * Set the transaction type.
+     *
+     * @param {TransactionType} transactionType The transaction type to be set.
+     */
+    transactionType(transactionType) {
+        this._type = transactionType;
+    }
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs() {
+        if (!this.suiTransaction) {
+            return;
+        }
+        const tx = this.suiTransaction;
+        const payTx = tx.tx;
+        const recipients = payTx.recipients;
+        const amounts = payTx.amounts;
+        if (tx.type !== iface_1.SuiTransactionType.PayAllSui && recipients.length !== amounts.length) {
+            throw new Error(`The length of recipients ${recipients.length} does not equal to the length of amounts ${amounts.length}`);
+        }
+        const isEmptyAmount = amounts.length === 0;
+        this._outputs = recipients.map((recipient, index) => ({
+            address: recipient,
+            value: isEmptyAmount ? '' : amounts[index].toString(),
+            coin: this._coinConfig.name,
+        }));
+        const totalAmount = isEmptyAmount ? '' : amounts.reduce((accumulator, current) => accumulator + current, 0);
+        this._inputs = [
+            {
+                address: tx.sender,
+                value: totalAmount.toString(),
+                coin: this._coinConfig.name,
+            },
+        ];
+    }
+    /**
+     * Sets this transaction payload
+     *
+     * @param {string} rawTransaction
+     */
+    fromRawTransaction(rawTransaction) {
+        try {
+            utils_1.default.isValidRawTransaction(rawTransaction);
+            this._suiTransaction = transaction_1.Transaction.deserializeSuiTransaction(rawTransaction);
+            this._type = sdk_core_1.TransactionType.Send;
+            this.loadInputsAndOutputs();
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /**
+     * Helper function for serialize() to get the correct txData with transaction type
+     *
+     * @return {TxData}
+     */
+    getTxData() {
+        if (!this._suiTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('empty transaction');
+        }
+        const suiTx = this._suiTransaction;
+        let tx;
+        switch (suiTx.type) {
+            case iface_1.SuiTransactionType.Pay:
+                tx = {
+                    Pay: {
+                        coins: suiTx.tx.coins,
+                        recipients: suiTx.tx.recipients,
+                        amounts: suiTx.tx.amounts,
+                    },
+                };
+                break;
+            case iface_1.SuiTransactionType.PaySui:
+                tx = {
+                    PaySui: {
+                        coins: suiTx.tx.coins,
+                        recipients: suiTx.tx.recipients,
+                        amounts: suiTx.tx.amounts,
+                    },
+                };
+                break;
+            case iface_1.SuiTransactionType.PayAllSui:
+                tx = {
+                    PayAllSui: {
+                        coins: suiTx.tx.coins,
+                        recipient: suiTx.tx.recipients[0],
+                    },
+                };
+                break;
+            default:
+                throw new sdk_core_1.InvalidTransactionError('SuiTransactionType not supported');
+        }
+        return {
+            kind: { Single: tx },
+            gasPayment: suiTx.gasPayment,
+            gasPrice: constants_1.SUI_GAS_PRICE,
+            gasBudget: suiTx.gasBudget,
+            sender: suiTx.sender,
+        };
+    }
+    /**
+     * Returns a complete explanation for a transfer transaction
+     * @param {TxData} json The transaction data in json format
+     * @param {TransactionExplanation} explanationResult The transaction explanation to be completed
+     * @returns {TransactionExplanation}
+     */
+    explainTransferTransaction(json, explanationResult) {
+        const recipients = this.suiTransaction.tx.recipients;
+        const amounts = this.suiTransaction.tx.amounts;
+        const outputs = recipients.map((recipient, index) => ({
+            address: recipient,
+            amount: amounts.length === 0 ? '' : amounts[index].toString(),
+        }));
+        const outputAmount = amounts.reduce((accumulator, current) => accumulator + current, 0);
+        return {
+            ...explanationResult,
+            outputAmount,
+            outputs,
+        };
+    }
+}
+exports.TransferTransaction = TransferTransaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferTransaction.js","sourceRoot":"","sources":["../../../src/lib/transferTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseKey,\n  InvalidTransactionError,\n  ParseTransactionError,\n  PublicKey as BasePublicKey,\n  Signature,\n  TransactionRecipient,\n  TransactionType,\n} from '@bitgo/sdk-core';\nimport {\n  PayTx,\n  SuiObjectRef,\n  SuiTransaction,\n  SuiTransactionType,\n  TransactionExplanation,\n  TxData,\n  TxDetails,\n} from './iface';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport utils from './utils';\nimport { SUI_GAS_PRICE, UNAVAILABLE_TEXT } from './constants';\nimport { Buffer } from 'buffer';\nimport { Transaction } from './transaction';\n\nexport class TransferTransaction extends Transaction<PayTx> {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  get suiTransaction(): SuiTransaction<PayTx> {\n    return this._suiTransaction;\n  }\n\n  setSuiTransaction(tx: SuiTransaction<PayTx>): void {\n    this._suiTransaction = tx;\n  }\n\n  /** @inheritDoc **/\n  get id(): string {\n    return this._id || UNAVAILABLE_TEXT;\n  }\n\n  addSignature(publicKey: BasePublicKey, signature: Buffer): void {\n    this._signatures.push(signature.toString('hex'));\n    this._signature = { publicKey, signature };\n    this.serialize();\n  }\n\n  get suiSignature(): Signature {\n    return this._signature;\n  }\n\n  getInputCoins(): SuiObjectRef[] {\n    return this.suiTransaction.tx.coins;\n  }\n\n  /** @inheritdoc */\n  canSign(key: BaseKey): boolean {\n    return true;\n  }\n\n  /** @inheritdoc */\n  toBroadcastFormat(): string {\n    if (!this._suiTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    return this.serialize();\n  }\n\n  /** @inheritdoc */\n  toJson(): TxData {\n    if (!this._suiTransaction) {\n      throw new ParseTransactionError('Empty transaction');\n    }\n\n    const tx = this._suiTransaction;\n    let txDetails: TxDetails;\n\n    switch (tx.type) {\n      case SuiTransactionType.Pay:\n        txDetails = {\n          Pay: {\n            coins: tx.tx.coins,\n            recipients: tx.tx.recipients,\n            amounts: tx.tx.amounts,\n          },\n        };\n        break;\n      case SuiTransactionType.PaySui:\n        txDetails = {\n          PaySui: {\n            coins: tx.tx.coins,\n            recipients: tx.tx.recipients,\n            amounts: tx.tx.amounts,\n          },\n        };\n        break;\n      case SuiTransactionType.PayAllSui:\n        txDetails = {\n          PayAllSui: {\n            coins: tx.tx.coins,\n            recipient: tx.tx.recipients[0],\n          },\n        };\n        break;\n      default:\n        throw new InvalidTransactionError('SuiTransactionType not supported');\n    }\n\n    return {\n      id: this._id,\n      kind: { Single: txDetails },\n      sender: tx.sender,\n      gasPayment: tx.gasPayment,\n      gasBudget: tx.gasBudget,\n      gasPrice: SUI_GAS_PRICE,\n    };\n  }\n\n  /** @inheritDoc */\n  explainTransaction(): TransactionExplanation {\n    const result = this.toJson();\n    const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'];\n    const outputs: TransactionRecipient[] = [];\n\n    const explanationResult: TransactionExplanation = {\n      displayOrder,\n      id: this.id,\n      outputs,\n      outputAmount: '0',\n      changeOutputs: [],\n      changeAmount: '0',\n      fee: { fee: this.suiTransaction.gasBudget.toString() },\n      type: this.type,\n    };\n\n    switch (this.type) {\n      case TransactionType.Send:\n        return this.explainTransferTransaction(result, explanationResult);\n      default:\n        throw new InvalidTransactionError('Transaction type not supported');\n    }\n  }\n\n  /**\n   * Set the transaction type.\n   *\n   * @param {TransactionType} transactionType The transaction type to be set.\n   */\n  transactionType(transactionType: TransactionType): void {\n    this._type = transactionType;\n  }\n\n  /**\n   * Load the input and output data on this transaction.\n   */\n  loadInputsAndOutputs(): void {\n    if (!this.suiTransaction) {\n      return;\n    }\n\n    const tx = this.suiTransaction;\n    const payTx = tx.tx;\n    const recipients = payTx.recipients;\n    const amounts = payTx.amounts;\n    if (tx.type !== SuiTransactionType.PayAllSui && recipients.length !== amounts.length) {\n      throw new Error(\n        `The length of recipients ${recipients.length} does not equal to the length of amounts ${amounts.length}`\n      );\n    }\n\n    const isEmptyAmount = amounts.length === 0;\n    this._outputs = recipients.map((recipient, index) => ({\n      address: recipient,\n      value: isEmptyAmount ? '' : amounts[index].toString(),\n      coin: this._coinConfig.name,\n    }));\n\n    const totalAmount = isEmptyAmount ? '' : amounts.reduce((accumulator, current) => accumulator + current, 0);\n    this._inputs = [\n      {\n        address: tx.sender,\n        value: totalAmount.toString(),\n        coin: this._coinConfig.name,\n      },\n    ];\n  }\n\n  /**\n   * Sets this transaction payload\n   *\n   * @param {string} rawTransaction\n   */\n  fromRawTransaction(rawTransaction: string): void {\n    try {\n      utils.isValidRawTransaction(rawTransaction);\n      this._suiTransaction = Transaction.deserializeSuiTransaction(rawTransaction) as SuiTransaction<PayTx>;\n      this._type = TransactionType.Send;\n      this.loadInputsAndOutputs();\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /**\n   * Helper function for serialize() to get the correct txData with transaction type\n   *\n   * @return {TxData}\n   */\n  public getTxData(): TxData {\n    if (!this._suiTransaction) {\n      throw new InvalidTransactionError('empty transaction');\n    }\n    const suiTx = this._suiTransaction;\n    let tx: TxDetails;\n\n    switch (suiTx.type) {\n      case SuiTransactionType.Pay:\n        tx = {\n          Pay: {\n            coins: suiTx.tx.coins,\n            recipients: suiTx.tx.recipients,\n            amounts: suiTx.tx.amounts,\n          },\n        };\n        break;\n      case SuiTransactionType.PaySui:\n        tx = {\n          PaySui: {\n            coins: suiTx.tx.coins,\n            recipients: suiTx.tx.recipients,\n            amounts: suiTx.tx.amounts,\n          },\n        };\n        break;\n      case SuiTransactionType.PayAllSui:\n        tx = {\n          PayAllSui: {\n            coins: suiTx.tx.coins,\n            recipient: suiTx.tx.recipients[0],\n          },\n        };\n        break;\n      default:\n        throw new InvalidTransactionError('SuiTransactionType not supported');\n    }\n\n    return {\n      kind: { Single: tx },\n      gasPayment: suiTx.gasPayment,\n      gasPrice: SUI_GAS_PRICE,\n      gasBudget: suiTx.gasBudget,\n      sender: suiTx.sender,\n    };\n  }\n\n  /**\n   * Returns a complete explanation for a transfer transaction\n   * @param {TxData} json The transaction data in json format\n   * @param {TransactionExplanation} explanationResult The transaction explanation to be completed\n   * @returns {TransactionExplanation}\n   */\n  explainTransferTransaction(json: TxData, explanationResult: TransactionExplanation): TransactionExplanation {\n    const recipients = this.suiTransaction.tx.recipients;\n    const amounts = this.suiTransaction.tx.amounts;\n\n    const outputs: TransactionRecipient[] = recipients.map((recipient, index) => ({\n      address: recipient,\n      amount: amounts.length === 0 ? '' : amounts[index].toString(),\n    }));\n    const outputAmount = amounts.reduce((accumulator, current) => accumulator + current, 0);\n\n    return {\n      ...explanationResult,\n      outputAmount,\n      outputs,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,7 @@
+import joi from 'joi';
+export declare const RequestAddDelegationTransactionSchema: joi.ObjectSchema<any>;
+export declare const RequestWithdrawDelegationTransactionSchema: joi.ObjectSchema<any>;
+export declare const RequestSwitchDelegationTransactionSchema: joi.ObjectSchema<any>;
+export declare const StakeTransactionSchema: joi.AlternativesSchema<any>;
+export declare const SuiMoveCallTransactionSchema: joi.ObjectSchema<any>;
+//# sourceMappingURL=txnSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txnSchema.d.ts","sourceRoot":"","sources":["../../../src/lib/txnSchema.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AA6EtB,eAAO,MAAM,qCAAqC,uBAMhD,CAAC;AAEH,eAAO,MAAM,0CAA0C,uBAMrD,CAAC;AAEH,eAAO,MAAM,wCAAwC,uBAMnD,CAAC;AAEH,eAAO,MAAM,sBAAsB,6BAAuE,CAAC;AAC3G,eAAO,MAAM,4BAA4B,uBAcvC,CAAC"}