@bitgo-beta/sdk-coin-sui 3.0.3-beta.20 → 3.0.3-beta.2000

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

@@ -0,0 +1,93 @@
+import { TransactionType, Recipient, BaseKey } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { SuiTransaction, TokenTransferProgrammableTransaction } from './iface';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { TokenTransferTransaction } from './tokenTransferTransaction';
+import { SuiObjectRef } from './mystenlab/types';
+import BigNumber from 'bignumber.js';
+export declare class TokenTransferBuilder extends TransactionBuilder<TokenTransferProgrammableTransaction> {
+    protected _recipients: Recipient[];
+    protected _inputObjects: SuiObjectRef[];
+    /**
+     * Balance held in the address balance system for the token being transferred.
+     * When set, this amount is included in the total available balance.
+     * At execution time, tx.withdrawal() + 0x2::coin::redeem_funds converts it
+     * to a Coin<T> that is merged with any coin objects before splitting.
+     */
+    protected _fundsInAddressBalance: BigNumber;
+    /**
+     * Coin type recovered from a deserialized transaction (the `redeem_funds` type argument /
+     * `BalanceWithdrawal` type). When set it takes precedence over the coin type derived from the
+     * coin config, so re-building a transaction (e.g. to attach a TSS signature before broadcast)
+     * preserves the exact coin type it was signed with even when the builder was constructed with
+     * the parent chain config rather than the token config.
+     */
+    protected _tokenCoinTypeOverride?: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /**
+     * The full coin type string derived from the coin config (e.g. `0xabc::my_token::MY_TOKEN`).
+     */
+    private get tokenCoinType();
+    /** @inheritdoc */
+    validateTransaction(transaction: TokenTransferTransaction): void;
+    /** @inheritdoc */
+    sign(key: BaseKey): void;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction<TokenTransferProgrammableTransaction>;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction<TokenTransferProgrammableTransaction>>;
+    /** @inheritdoc */
+    initBuilder(tx: TokenTransferTransaction): void;
+    send(recipients: Recipient[]): this;
+    inputObjects(inputObject: SuiObjectRef[]): this;
+    /**
+     * Set the amount of token funds held in the Sui address balance system for this sender.
+     *
+     * @param {string} amount - amount in base units held in address balance
+     */
+    fundsInAddressBalance(amount: string): this;
+    /**
+     * Validates all fields are defined correctly
+     */
+    private validateTransactionFields;
+    /** Validates the individual object refs (does not require non-empty array). */
+    private validateInputObjectRefs;
+    /**
+     * Build SuiTransaction.
+     *
+     * Two build paths:
+     *
+     * Path A — coin objects only (fundsInAddressBalance = 0):
+     *   MergeCoins(inputObject[0], [inputObject[1..]]) → SplitCoins → TransferObjects
+     *
+     * Path B — coin objects + address balance (or address balance only):
+     *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>
+     *   MergeCoins(inputObject[0] | addrCoin, [rest...]) → SplitCoins → TransferObjects
+     *
+     *   Exception A — addr-bal only, full amount (fundsInAddressBalance === sum(recipient amounts)):
+     *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>
+     *   SplitCoins(addrCoin, [amount0]) → TransferObjects(split0, addr0)   # recipients 0..N-2
+     *   ...
+     *   TransferObjects([addrCoin], addrN-1)                                # last recipient directly
+     *   (After N-1 splits addrCoin.balance === recipients[N-1].amount exactly, so it can be
+     *   transferred directly. SplitCoins on the last recipient would leave a zero-balance Coin<T>
+     *   unused, which causes UnusedValueWithoutDrop since Coin<T> has no drop ability.)
+     *
+     *   Exception B — addr-bal only, partial amount (fundsInAddressBalance > sum(recipient amounts)):
+     *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>
+     *   SplitCoins(addrCoin, [amount0]) → TransferObjects(split0, addr0)   # all recipients
+     *   ...
+     *   TransferObjects([addrCoin], sender)                                 # return change to sender
+     *   (addrCoin still holds the unspent remainder; transferring it back to the sender consumes
+     *   the command result, avoiding UnusedValueWithoutDrop. Mirrors the native SUI TransferBuilder
+     *   change-return path. Unlike native SUI, MergeCoins(gas, [addrCoin]) is not possible here
+     *   because gas is Coin<SUI> and addrCoin is Coin<T> — incompatible types.)
+     *
+     * @return {SuiTransaction<TokenTransferProgrammableTransaction>}
+     * @protected
+     */
+    protected buildSuiTransaction(): SuiTransaction<TokenTransferProgrammableTransaction>;
+}
+//# sourceMappingURL=tokenTransferBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenTransferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/tokenTransferBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,SAAS,EAAyB,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAClG,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAW,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAsB,oCAAoC,EAAE,MAAM,SAAS,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAuB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAQtE,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,qBAAa,oBAAqB,SAAQ,kBAAkB,CAAC,oCAAoC,CAAC;IAChG,SAAS,CAAC,WAAW,EAAE,SAAS,EAAE,CAAC;IACnC,SAAS,CAAC,aAAa,EAAE,YAAY,EAAE,CAAC;IACxC;;;;;OAKG;IACH,SAAS,CAAC,sBAAsB,EAAE,SAAS,CAAoB;IAE/D;;;;;;OAMG;IACH,SAAS,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;gBAE9B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;OAEG;IACH,OAAO,KAAK,aAAa,GAMxB;IAED,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,EAAE,wBAAwB,GAAG,IAAI;IAOhE,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAKxB,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,CAAC,oCAAoC,CAAC;IAQvG,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC,oCAAoC,CAAC,CAAC;IAgBjG,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,wBAAwB,GAAG,IAAI;IAkD/C,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI;IAMnC,YAAY,CAAC,WAAW,EAAE,YAAY,EAAE,GAAG,IAAI;IAM/C;;;;OAIG;IACH,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK3C;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAoBjC,+EAA+E;IAC/E,OAAO,CAAC,uBAAuB;IAQ/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,SAAS,CAAC,mBAAmB,IAAI,cAAc,CAAC,oCAAoC,CAAC;CA+EtF"}

package/dist/src/lib/tokenTransferBuilder.js

@@ -0,0 +1,266 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTransferBuilder = void 0;
+const assert_1 = __importDefault(require("assert"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const iface_1 = require("./iface");
+const transactionBuilder_1 = require("./transactionBuilder");
+const tokenTransferTransaction_1 = require("./tokenTransferTransaction");
+const types_1 = require("./mystenlab/types");
+const utils_1 = __importDefault(require("./utils"));
+const builder_1 = require("./mystenlab/builder");
+const type_tag_serializer_1 = require("./mystenlab/txn-data-serializers/type-tag-serializer");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+class TokenTransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        /**
+         * Balance held in the address balance system for the token being transferred.
+         * When set, this amount is included in the total available balance.
+         * At execution time, tx.withdrawal() + 0x2::coin::redeem_funds converts it
+         * to a Coin<T> that is merged with any coin objects before splitting.
+         */
+        this._fundsInAddressBalance = new bignumber_js_1.default(0);
+        this._transaction = new tokenTransferTransaction_1.TokenTransferTransaction(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    /**
+     * The full coin type string derived from the coin config (e.g. `0xabc::my_token::MY_TOKEN`).
+     */
+    get tokenCoinType() {
+        if (this._tokenCoinTypeOverride) {
+            return this._tokenCoinTypeOverride;
+        }
+        const config = this._coinConfig;
+        return `${config.packageId}::${config.module}::${config.symbol}`;
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        if (!transaction.suiTransaction) {
+            return;
+        }
+        this.validateTransactionFields();
+    }
+    /** @inheritdoc */
+    sign(key) {
+        this.transaction.setSuiTransaction(this.buildSuiTransaction());
+        super.sign(key);
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = new tokenTransferTransaction_1.TokenTransferTransaction(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;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        this._transaction = tx;
+        if (tx.signature && tx.signature.length > 0) {
+            this._signatures = [tx.suiSignature];
+        }
+        const txData = tx.toJson();
+        this.type(iface_1.SuiTransactionType.TokenTransfer);
+        this.sender(txData.sender);
+        this.gasData(txData.gasData);
+        // Only restore meaningful expirations (Epoch or ValidDuring) — ignore None.
+        if (txData.expiration && !('None' in txData.expiration)) {
+            this._expiration = txData.expiration;
+        }
+        const recipients = utils_1.default.getRecipients(tx.suiTransaction);
+        this.send(recipients);
+        // Reconstruct fundsInAddressBalance from BalanceWithdrawal input if present.
+        // After BCS deserialization inputs are CallArg format: { BalanceWithdrawal: {...} }
+        // During building they are TransactionBlockInput format: { kind:'Input', value: { BalanceWithdrawal: {...} } }
+        const withdrawalInput = tx.suiTransaction?.tx?.inputs?.find((input) => (input !== null && typeof input === 'object' && 'BalanceWithdrawal' in input) ||
+            (input?.value !== null && typeof input?.value === 'object' && 'BalanceWithdrawal' in (input.value ?? {})));
+        if (withdrawalInput) {
+            const bw = withdrawalInput.BalanceWithdrawal ?? withdrawalInput.value?.BalanceWithdrawal;
+            this._fundsInAddressBalance = new bignumber_js_1.default(String(bw.reservation?.MaxAmountU64 ?? bw.amount));
+            // Recover the coin type from the withdrawal's TypeTag so that re-building uses the exact
+            // coin type the transaction was created (and signed) with. Without this, buildSuiTransaction
+            // would re-derive the coin type from this._coinConfig, which is the parent chain config
+            // (no packageId/module/symbol) when the builder is constructed via the chain — producing an
+            // `undefined::undefined::undefined` coin type and a signature that fails on-chain verification.
+            const withdrawalTypeTag = bw?.typeArg?.Balance;
+            if (withdrawalTypeTag) {
+                // BCS decodes the struct address without the `0x` prefix; normalize it so the recovered
+                // coin type matches the config-derived form (`0x<addr>::module::name`). The serialized
+                // bytes are identical either way since parseFromStr re-normalizes the address on encode.
+                const [address, ...rest] = type_tag_serializer_1.TypeTagSerializer.tagToString(withdrawalTypeTag).split('::');
+                this._tokenCoinTypeOverride = [(0, types_1.normalizeSuiAddress)(address), ...rest].join('::');
+            }
+        }
+        if (txData.inputObjects && txData.inputObjects.length > 0) {
+            this.inputObjects(txData.inputObjects);
+        }
+    }
+    send(recipients) {
+        this.validateRecipients(recipients);
+        this._recipients = recipients;
+        return this;
+    }
+    inputObjects(inputObject) {
+        this.validateInputObjectRefs(inputObject);
+        this._inputObjects = inputObject;
+        return this;
+    }
+    /**
+     * Set the amount of token funds held in the Sui address balance system for this sender.
+     *
+     * @param {string} amount - amount in base units held in address balance
+     */
+    fundsInAddressBalance(amount) {
+        this._fundsInAddressBalance = new bignumber_js_1.default(amount);
+        return this;
+    }
+    /**
+     * Validates all fields are defined correctly
+     */
+    validateTransactionFields() {
+        (0, assert_1.default)(this._type, new sdk_core_1.BuildTransactionError('type is required before building'));
+        (0, assert_1.default)(this._sender, new sdk_core_1.BuildTransactionError('sender is required before building'));
+        (0, assert_1.default)(this._recipients && this._recipients.length > 0, new sdk_core_1.BuildTransactionError('at least one recipient is required before building'));
+        (0, assert_1.default)(this._gasData, new sdk_core_1.BuildTransactionError('gasData is required before building'));
+        this.validateGasData(this._gasData);
+        // Must have at least coin objects OR address balance
+        (0, assert_1.default)((this._inputObjects && this._inputObjects.length > 0) || this._fundsInAddressBalance.gt(0), new sdk_core_1.BuildTransactionError('input objects or fundsInAddressBalance required before building'));
+        if (this._inputObjects && this._inputObjects.length > 0) {
+            this.validateInputObjectRefs(this._inputObjects);
+        }
+    }
+    /** Validates the individual object refs (does not require non-empty array). */
+    validateInputObjectRefs(inputObjects) {
+        if (inputObjects) {
+            inputObjects.forEach((inputObject) => {
+                this.validateSuiObjectRef(inputObject, 'input object');
+            });
+        }
+    }
+    /**
+     * Build SuiTransaction.
+     *
+     * Two build paths:
+     *
+     * Path A — coin objects only (fundsInAddressBalance = 0):
+     *   MergeCoins(inputObject[0], [inputObject[1..]]) → SplitCoins → TransferObjects
+     *
+     * Path B — coin objects + address balance (or address balance only):
+     *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>
+     *   MergeCoins(inputObject[0] | addrCoin, [rest...]) → SplitCoins → TransferObjects
+     *
+     *   Exception A — addr-bal only, full amount (fundsInAddressBalance === sum(recipient amounts)):
+     *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>
+     *   SplitCoins(addrCoin, [amount0]) → TransferObjects(split0, addr0)   # recipients 0..N-2
+     *   ...
+     *   TransferObjects([addrCoin], addrN-1)                                # last recipient directly
+     *   (After N-1 splits addrCoin.balance === recipients[N-1].amount exactly, so it can be
+     *   transferred directly. SplitCoins on the last recipient would leave a zero-balance Coin<T>
+     *   unused, which causes UnusedValueWithoutDrop since Coin<T> has no drop ability.)
+     *
+     *   Exception B — addr-bal only, partial amount (fundsInAddressBalance > sum(recipient amounts)):
+     *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>
+     *   SplitCoins(addrCoin, [amount0]) → TransferObjects(split0, addr0)   # all recipients
+     *   ...
+     *   TransferObjects([addrCoin], sender)                                 # return change to sender
+     *   (addrCoin still holds the unspent remainder; transferring it back to the sender consumes
+     *   the command result, avoiding UnusedValueWithoutDrop. Mirrors the native SUI TransferBuilder
+     *   change-return path. Unlike native SUI, MergeCoins(gas, [addrCoin]) is not possible here
+     *   because gas is Coin<SUI> and addrCoin is Coin<T> — incompatible types.)
+     *
+     * @return {SuiTransaction<TokenTransferProgrammableTransaction>}
+     * @protected
+     */
+    buildSuiTransaction() {
+        this.validateTransactionFields();
+        const programmableTxBuilder = new builder_1.TransactionBlock();
+        const inputObjects = (this._inputObjects ?? []).map((object) => programmableTxBuilder.object(builder_1.Inputs.ObjectRef(object)));
+        // If address balance is available, withdraw it as Coin<T> and add to the pool
+        if (this._fundsInAddressBalance.gt(0)) {
+            const coinType = this.tokenCoinType;
+            const [addrCoin] = programmableTxBuilder.moveCall({
+                target: '0x2::coin::redeem_funds',
+                typeArguments: [coinType],
+                arguments: [
+                    programmableTxBuilder.withdrawal({
+                        amount: BigInt(this._fundsInAddressBalance.toFixed()),
+                        type: coinType,
+                    }),
+                ],
+            });
+            inputObjects.push(addrCoin);
+        }
+        const mergedObject = inputObjects.shift();
+        if (inputObjects.length > 0) {
+            programmableTxBuilder.mergeCoins(mergedObject, inputObjects);
+        }
+        // addrCoin (the Coin<T> returned by redeem_funds) is a command result and must be explicitly
+        // consumed — Coin<T> has no `drop` ability, so leaving it unused causes UnusedValueWithoutDrop.
+        // This only applies when there are no coin objects (addr-bal only); in the hybrid case addrCoin
+        // is consumed upfront by the MergeCoins above.
+        const recipientTotal = this._recipients.reduce((sum, r) => sum.plus(r.amount), new bignumber_js_1.default(0));
+        const isAddrBalOnly = (this._inputObjects ?? []).length === 0 && this._fundsInAddressBalance.gt(0);
+        if (isAddrBalOnly && this._fundsInAddressBalance.eq(recipientTotal)) {
+            // Exception A — full amount: split for first N-1 recipients, transfer addrCoin directly
+            // to the last. After N-1 splits addrCoin.balance === recipients[N-1].amount exactly.
+            this._recipients.slice(0, -1).forEach((recipient) => {
+                const splitObject = programmableTxBuilder.splitCoins(mergedObject, [
+                    programmableTxBuilder.pure(BigInt(recipient.amount)),
+                ]);
+                programmableTxBuilder.transferObjects([splitObject], programmableTxBuilder.object(recipient.address));
+            });
+            const lastRecipient = this._recipients[this._recipients.length - 1];
+            programmableTxBuilder.transferObjects([mergedObject], programmableTxBuilder.object(lastRecipient.address));
+        }
+        else {
+            // Standard path: split and transfer for every recipient.
+            this._recipients.forEach((recipient) => {
+                const splitObject = programmableTxBuilder.splitCoins(mergedObject, [
+                    programmableTxBuilder.pure(BigInt(recipient.amount)),
+                ]);
+                programmableTxBuilder.transferObjects([splitObject], programmableTxBuilder.object(recipient.address));
+            });
+            if (isAddrBalOnly && this._fundsInAddressBalance.gt(recipientTotal)) {
+                // Exception B — partial amount: addrCoin still holds the unspent remainder.
+                // Return it to the sender to consume the command result (MergeCoins into gas is not
+                // possible here — gas is Coin<SUI> but addrCoin is Coin<T>, incompatible types).
+                programmableTxBuilder.transferObjects([mergedObject], programmableTxBuilder.object(this._sender));
+            }
+        }
+        const txData = programmableTxBuilder.blockData;
+        return {
+            type: this._type,
+            sender: this._sender,
+            tx: {
+                inputs: [...txData.inputs],
+                transactions: [...txData.transactions],
+            },
+            gasData: {
+                ...this._gasData,
+            },
+            expiration: this._expiration,
+            fundsInAddressBalance: this._fundsInAddressBalance.gt(0) ? this._fundsInAddressBalance.toFixed() : undefined,
+        };
+    }
+}
+exports.TokenTransferBuilder = TokenTransferBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenTransferBuilder.js","sourceRoot":"","sources":["../../../src/lib/tokenTransferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport { TransactionType, Recipient, BuildTransactionError, BaseKey } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig, SuiCoin } from '@bitgo-beta/statics';\nimport { SuiTransaction, SuiTransactionType, TokenTransferProgrammableTransaction } from './iface';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { TokenTransferTransaction } from './tokenTransferTransaction';\nimport { normalizeSuiAddress, SuiObjectRef } from './mystenlab/types';\nimport utils from './utils';\nimport {\n  Inputs,\n  TransactionBlock as ProgrammingTransactionBlockBuilder,\n  TransactionArgument,\n} from './mystenlab/builder';\nimport { TypeTagSerializer } from './mystenlab/txn-data-serializers/type-tag-serializer';\nimport BigNumber from 'bignumber.js';\n\nexport class TokenTransferBuilder extends TransactionBuilder<TokenTransferProgrammableTransaction> {\n  protected _recipients: Recipient[];\n  protected _inputObjects: SuiObjectRef[];\n  /**\n   * Balance held in the address balance system for the token being transferred.\n   * When set, this amount is included in the total available balance.\n   * At execution time, tx.withdrawal() + 0x2::coin::redeem_funds converts it\n   * to a Coin<T> that is merged with any coin objects before splitting.\n   */\n  protected _fundsInAddressBalance: BigNumber = new BigNumber(0);\n\n  /**\n   * Coin type recovered from a deserialized transaction (the `redeem_funds` type argument /\n   * `BalanceWithdrawal` type). When set it takes precedence over the coin type derived from the\n   * coin config, so re-building a transaction (e.g. to attach a TSS signature before broadcast)\n   * preserves the exact coin type it was signed with even when the builder was constructed with\n   * the parent chain config rather than the token config.\n   */\n  protected _tokenCoinTypeOverride?: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new TokenTransferTransaction(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Send;\n  }\n\n  /**\n   * The full coin type string derived from the coin config (e.g. `0xabc::my_token::MY_TOKEN`).\n   */\n  private get tokenCoinType(): string {\n    if (this._tokenCoinTypeOverride) {\n      return this._tokenCoinTypeOverride;\n    }\n    const config = this._coinConfig as SuiCoin;\n    return `${config.packageId}::${config.module}::${config.symbol}`;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction: TokenTransferTransaction): void {\n    if (!transaction.suiTransaction) {\n      return;\n    }\n    this.validateTransactionFields();\n  }\n\n  /** @inheritdoc */\n  sign(key: BaseKey): void {\n    this.transaction.setSuiTransaction(this.buildSuiTransaction());\n    super.sign(key);\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction<TokenTransferProgrammableTransaction> {\n    const tx = new TokenTransferTransaction(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<TokenTransferProgrammableTransaction>> {\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  /** @inheritdoc */\n  initBuilder(tx: TokenTransferTransaction): void {\n    this._transaction = tx;\n\n    if (tx.signature && tx.signature.length > 0) {\n      this._signatures = [tx.suiSignature];\n    }\n    const txData = tx.toJson();\n    this.type(SuiTransactionType.TokenTransfer);\n    this.sender(txData.sender);\n    this.gasData(txData.gasData);\n\n    // Only restore meaningful expirations (Epoch or ValidDuring) — ignore None.\n    if (txData.expiration && !('None' in txData.expiration)) {\n      this._expiration = txData.expiration;\n    }\n\n    const recipients = utils.getRecipients(tx.suiTransaction);\n    this.send(recipients);\n\n    // Reconstruct fundsInAddressBalance from BalanceWithdrawal input if present.\n    // After BCS deserialization inputs are CallArg format: { BalanceWithdrawal: {...} }\n    // During building they are TransactionBlockInput format: { kind:'Input', value: { BalanceWithdrawal: {...} } }\n    const withdrawalInput = (tx.suiTransaction?.tx?.inputs as any[])?.find(\n      (input: any) =>\n        (input !== null && typeof input === 'object' && 'BalanceWithdrawal' in input) ||\n        (input?.value !== null && typeof input?.value === 'object' && 'BalanceWithdrawal' in (input.value ?? {}))\n    );\n    if (withdrawalInput) {\n      const bw = withdrawalInput.BalanceWithdrawal ?? withdrawalInput.value?.BalanceWithdrawal;\n      this._fundsInAddressBalance = new BigNumber(String(bw.reservation?.MaxAmountU64 ?? bw.amount));\n      // Recover the coin type from the withdrawal's TypeTag so that re-building uses the exact\n      // coin type the transaction was created (and signed) with. Without this, buildSuiTransaction\n      // would re-derive the coin type from this._coinConfig, which is the parent chain config\n      // (no packageId/module/symbol) when the builder is constructed via the chain — producing an\n      // `undefined::undefined::undefined` coin type and a signature that fails on-chain verification.\n      const withdrawalTypeTag = bw?.typeArg?.Balance;\n      if (withdrawalTypeTag) {\n        // BCS decodes the struct address without the `0x` prefix; normalize it so the recovered\n        // coin type matches the config-derived form (`0x<addr>::module::name`). The serialized\n        // bytes are identical either way since parseFromStr re-normalizes the address on encode.\n        const [address, ...rest] = TypeTagSerializer.tagToString(withdrawalTypeTag).split('::');\n        this._tokenCoinTypeOverride = [normalizeSuiAddress(address), ...rest].join('::');\n      }\n    }\n\n    if (txData.inputObjects && txData.inputObjects.length > 0) {\n      this.inputObjects(txData.inputObjects);\n    }\n  }\n\n  send(recipients: Recipient[]): this {\n    this.validateRecipients(recipients);\n    this._recipients = recipients;\n    return this;\n  }\n\n  inputObjects(inputObject: SuiObjectRef[]): this {\n    this.validateInputObjectRefs(inputObject);\n    this._inputObjects = inputObject;\n    return this;\n  }\n\n  /**\n   * Set the amount of token funds held in the Sui address balance system for this sender.\n   *\n   * @param {string} amount - amount in base units held in address balance\n   */\n  fundsInAddressBalance(amount: string): this {\n    this._fundsInAddressBalance = new BigNumber(amount);\n    return this;\n  }\n\n  /**\n   * Validates all fields are defined correctly\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(\n      this._recipients && this._recipients.length > 0,\n      new BuildTransactionError('at least one recipient is required before building')\n    );\n    assert(this._gasData, new BuildTransactionError('gasData is required before building'));\n    this.validateGasData(this._gasData);\n\n    // Must have at least coin objects OR address balance\n    assert(\n      (this._inputObjects && this._inputObjects.length > 0) || this._fundsInAddressBalance.gt(0),\n      new BuildTransactionError('input objects or fundsInAddressBalance required before building')\n    );\n    if (this._inputObjects && this._inputObjects.length > 0) {\n      this.validateInputObjectRefs(this._inputObjects);\n    }\n  }\n\n  /** Validates the individual object refs (does not require non-empty array). */\n  private validateInputObjectRefs(inputObjects: SuiObjectRef[]): void {\n    if (inputObjects) {\n      inputObjects.forEach((inputObject) => {\n        this.validateSuiObjectRef(inputObject, 'input object');\n      });\n    }\n  }\n\n  /**\n   * Build SuiTransaction.\n   *\n   * Two build paths:\n   *\n   * Path A — coin objects only (fundsInAddressBalance = 0):\n   *   MergeCoins(inputObject[0], [inputObject[1..]]) → SplitCoins → TransferObjects\n   *\n   * Path B — coin objects + address balance (or address balance only):\n   *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>\n   *   MergeCoins(inputObject[0] | addrCoin, [rest...]) → SplitCoins → TransferObjects\n   *\n   *   Exception A — addr-bal only, full amount (fundsInAddressBalance === sum(recipient amounts)):\n   *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>\n   *   SplitCoins(addrCoin, [amount0]) → TransferObjects(split0, addr0)   # recipients 0..N-2\n   *   ...\n   *   TransferObjects([addrCoin], addrN-1)                                # last recipient directly\n   *   (After N-1 splits addrCoin.balance === recipients[N-1].amount exactly, so it can be\n   *   transferred directly. SplitCoins on the last recipient would leave a zero-balance Coin<T>\n   *   unused, which causes UnusedValueWithoutDrop since Coin<T> has no drop ability.)\n   *\n   *   Exception B — addr-bal only, partial amount (fundsInAddressBalance > sum(recipient amounts)):\n   *   MoveCall(0x2::coin::redeem_funds, [withdrawal(amount, coinType)]) → Coin<T>\n   *   SplitCoins(addrCoin, [amount0]) → TransferObjects(split0, addr0)   # all recipients\n   *   ...\n   *   TransferObjects([addrCoin], sender)                                 # return change to sender\n   *   (addrCoin still holds the unspent remainder; transferring it back to the sender consumes\n   *   the command result, avoiding UnusedValueWithoutDrop. Mirrors the native SUI TransferBuilder\n   *   change-return path. Unlike native SUI, MergeCoins(gas, [addrCoin]) is not possible here\n   *   because gas is Coin<SUI> and addrCoin is Coin<T> — incompatible types.)\n   *\n   * @return {SuiTransaction<TokenTransferProgrammableTransaction>}\n   * @protected\n   */\n  protected buildSuiTransaction(): SuiTransaction<TokenTransferProgrammableTransaction> {\n    this.validateTransactionFields();\n\n    const programmableTxBuilder = new ProgrammingTransactionBlockBuilder();\n\n    const inputObjects: TransactionArgument[] = (this._inputObjects ?? []).map((object) =>\n      programmableTxBuilder.object(Inputs.ObjectRef(object))\n    );\n\n    // If address balance is available, withdraw it as Coin<T> and add to the pool\n    if (this._fundsInAddressBalance.gt(0)) {\n      const coinType = this.tokenCoinType;\n      const [addrCoin] = programmableTxBuilder.moveCall({\n        target: '0x2::coin::redeem_funds',\n        typeArguments: [coinType],\n        arguments: [\n          programmableTxBuilder.withdrawal({\n            amount: BigInt(this._fundsInAddressBalance.toFixed()),\n            type: coinType,\n          }),\n        ],\n      });\n      inputObjects.push(addrCoin);\n    }\n\n    const mergedObject = inputObjects.shift() as TransactionArgument;\n    if (inputObjects.length > 0) {\n      programmableTxBuilder.mergeCoins(mergedObject, inputObjects);\n    }\n\n    // addrCoin (the Coin<T> returned by redeem_funds) is a command result and must be explicitly\n    // consumed — Coin<T> has no `drop` ability, so leaving it unused causes UnusedValueWithoutDrop.\n    // This only applies when there are no coin objects (addr-bal only); in the hybrid case addrCoin\n    // is consumed upfront by the MergeCoins above.\n    const recipientTotal = this._recipients.reduce((sum, r) => sum.plus(r.amount), new BigNumber(0));\n    const isAddrBalOnly = (this._inputObjects ?? []).length === 0 && this._fundsInAddressBalance.gt(0);\n\n    if (isAddrBalOnly && this._fundsInAddressBalance.eq(recipientTotal)) {\n      // Exception A — full amount: split for first N-1 recipients, transfer addrCoin directly\n      // to the last. After N-1 splits addrCoin.balance === recipients[N-1].amount exactly.\n      this._recipients.slice(0, -1).forEach((recipient) => {\n        const splitObject = programmableTxBuilder.splitCoins(mergedObject, [\n          programmableTxBuilder.pure(BigInt(recipient.amount)),\n        ]);\n        programmableTxBuilder.transferObjects([splitObject], programmableTxBuilder.object(recipient.address));\n      });\n      const lastRecipient = this._recipients[this._recipients.length - 1];\n      programmableTxBuilder.transferObjects([mergedObject], programmableTxBuilder.object(lastRecipient.address));\n    } else {\n      // Standard path: split and transfer for every recipient.\n      this._recipients.forEach((recipient) => {\n        const splitObject = programmableTxBuilder.splitCoins(mergedObject, [\n          programmableTxBuilder.pure(BigInt(recipient.amount)),\n        ]);\n        programmableTxBuilder.transferObjects([splitObject], programmableTxBuilder.object(recipient.address));\n      });\n      if (isAddrBalOnly && this._fundsInAddressBalance.gt(recipientTotal)) {\n        // Exception B — partial amount: addrCoin still holds the unspent remainder.\n        // Return it to the sender to consume the command result (MergeCoins into gas is not\n        // possible here — gas is Coin<SUI> but addrCoin is Coin<T>, incompatible types).\n        programmableTxBuilder.transferObjects([mergedObject], programmableTxBuilder.object(this._sender));\n      }\n    }\n\n    const txData = programmableTxBuilder.blockData;\n    return {\n      type: this._type,\n      sender: this._sender,\n      tx: {\n        inputs: [...txData.inputs],\n        transactions: [...txData.transactions],\n      },\n      gasData: {\n        ...this._gasData,\n      },\n      expiration: this._expiration,\n      fundsInAddressBalance: this._fundsInAddressBalance.gt(0) ? this._fundsInAddressBalance.toFixed() : undefined,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,59 @@
+import { SuiTransaction, TokenTransferProgrammableTransaction, TransactionExplanation, TxData } from './iface';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction } from './transaction';
+import { BaseKey, PublicKey as BasePublicKey, Signature, TransactionType } from '@bitgo-beta/sdk-core';
+export declare class TokenTransferTransaction extends Transaction<TokenTransferProgrammableTransaction> {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    get suiTransaction(): SuiTransaction<TokenTransferProgrammableTransaction>;
+    setSuiTransaction(tx: SuiTransaction<TokenTransferProgrammableTransaction>): void;
+    /** @inheritDoc */
+    get id(): string;
+    addSignature(publicKey: BasePublicKey, signature: Buffer): void;
+    get suiSignature(): Signature;
+    /** @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}
+     */
+    explainTokenTransferTransaction(json: TxData, explanationResult: TransactionExplanation): TransactionExplanation;
+    /**
+     * Extracts the objects that were provided as inputs while building the transaction.
+     * Handles both the simple case (MergeCoins/SplitCoins first) and the address-balance
+     * case where MoveCall(redeem_funds) may precede MergeCoins/SplitCoins.
+     * @param tx
+     * @returns {SuiObjectRef[]} Objects that are inputs for the transaction
+     */
+    private getInputObjectsFromTx;
+}
+//# sourceMappingURL=tokenTransferTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenTransferTransaction.d.ts","sourceRoot":"","sources":["../../../src/lib/tokenTransferTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,oCAAoC,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAC/G,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EACL,OAAO,EACP,SAAS,IAAI,aAAa,EAG1B,SAAS,EAET,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAa9B,qBAAa,wBAAyB,SAAQ,WAAW,CAAC,oCAAoC,CAAC;gBACjF,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,IAAI,cAAc,IAAI,cAAc,CAAC,oCAAoC,CAAC,CAEzE;IAED,iBAAiB,CAAC,EAAE,EAAE,cAAc,CAAC,oCAAoC,CAAC,GAAG,IAAI;IAIjF,kBAAkB;IAClB,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,kBAAkB;IAClB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAI9B,kBAAkB;IAClB,iBAAiB,IAAI,MAAM;IAO3B,kBAAkB;IAClB,MAAM,IAAI,MAAM;IAgBhB,kBAAkB;IAClB,kBAAkB,IAAI,sBAAsB;IAwB5C;;;;OAIG;IACH,eAAe,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAIvD;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAuB5B;;;;OAIG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAchD;;;;OAIG;IACI,SAAS,IAAI,MAAM;IAgD1B;;;;;OAKG;IACH,+BAA+B,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,sBAAsB,GAAG,sBAAsB;IAchH;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;CAiC9B"}