@bitgo-beta/sdk-coin-sol 7.6.4-beta.62 → 7.6.4-beta.621

package/dist/esm/lib/transferBuilderV2.js

@@ -0,0 +1,247 @@
+import { TransactionBuilder } from './transactionBuilder';
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { getAssociatedTokenAccountAddress, getSolTokenFromTokenName, isValidAmount, validateAddress, validateMintAddress, validateOwnerAddress, } from './utils';
+import assert from 'assert';
+import { InstructionBuilderTypes } from './constants';
+import _ from 'lodash';
+const UNSIGNED_BIGINT_MAX = BigInt('18446744073709551615');
+export class TransferBuilderV2 extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._sendParams = [];
+        this._createAtaParams = [];
+    }
+    /**
+     * Set the resolved sRFC-37 Token ACL permissionless-thaw params for this transfer.
+     *
+     * These must be resolved live by the caller (e.g. via `Sol.resolvePermissionlessThaw`) since
+     * builders remain offline and never perform RPC. When set, the built transaction bundles a
+     * `PermissionlessThawIdempotent` instruction after any ATA creation and before the transfer, so
+     * a freshly created (frozen) allowlist/blocklist token account is thawed atomically with the
+     * transfer — all-or-nothing.
+     *
+     * @param {PermissionlessThawIdempotent['params']} params - resolved thaw params
+     * @returns {TransferBuilderV2} This transaction builder
+     */
+    permissionlessThaw(params) {
+        this._permissionlessThaw = params;
+        return this;
+    }
+    /**
+     * Set the resolved Token-2022 Transfer Hook extra account metas for this transfer.
+     *
+     * These must be resolved live by the caller (e.g. via `Sol.resolveTransferHookAccounts`)
+     * since builders remain offline and never perform RPC. The order is significant and
+     * must match the hook's ExtraAccountMetaList.
+     *
+     * @param {ExtraAccountMeta[]} metas - resolved extra account metas, in hook order
+     * @returns {TransferBuilderV2} This transaction builder
+     */
+    transferHookAccounts(metas) {
+        this._transferHookAccounts = metas;
+        return this;
+    }
+    get transactionType() {
+        return TransactionType.Send;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.Transfer) {
+                const transferInstruction = instruction;
+                this.sender(transferInstruction.params.fromAddress);
+                this.send({
+                    address: transferInstruction.params.toAddress,
+                    amount: transferInstruction.params.amount,
+                });
+            }
+            else if (instruction.type === InstructionBuilderTypes.TokenTransfer) {
+                const transferInstruction = instruction;
+                this.sender(transferInstruction.params.fromAddress);
+                this.send({
+                    address: transferInstruction.params.toAddress,
+                    amount: transferInstruction.params.amount,
+                    tokenName: transferInstruction.params.tokenName,
+                });
+            }
+            else if (instruction.type === InstructionBuilderTypes.CreateAssociatedTokenAccount) {
+                const ataInitInstruction = instruction;
+                this._createAtaParams.push({
+                    ownerAddress: ataInitInstruction.params.ownerAddress,
+                    tokenName: ataInitInstruction.params.tokenName,
+                    ataAddress: ataInitInstruction.params.ataAddress,
+                });
+            }
+        }
+    }
+    /**
+     * Set a feePayer
+     * @param payerAddress
+     */
+    feePayer(payerAddress) {
+        validateAddress(payerAddress, 'address');
+        this._feePayer = payerAddress;
+        return this;
+    }
+    /**
+     *  Set a transfer
+     *
+     * @param {SendParams} sendParams - sendParams
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send(sendParams) {
+        validateAddress(sendParams.address, 'address');
+        if (!sendParams.amount || !isValidAmount(sendParams.amount)) {
+            throw new BuildTransactionError('Invalid or missing amount, got: ' + sendParams.amount);
+        }
+        if (sendParams.tokenName && BigInt(sendParams.amount) > UNSIGNED_BIGINT_MAX) {
+            throw new BuildTransactionError(`input amount ${sendParams.amount} exceeds big int limit ${UNSIGNED_BIGINT_MAX}`);
+        }
+        else if (!sendParams.tokenName && BigInt(sendParams.amount) > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new BuildTransactionError(`input amount ${sendParams.amount} exceeds max safe int ${Number.MAX_SAFE_INTEGER}`);
+        }
+        this._sendParams.push(sendParams);
+        return this;
+    }
+    /**
+     *
+     * @param {TokenAssociateRecipient} recipient - recipient of the associated token account creation
+     * @param {string} recipient.ownerAddress - owner of the associated token account
+     * @param {string} recipient.tokenName - name of the token that is intended to associate
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    createAssociatedTokenAccount(recipient) {
+        validateOwnerAddress(recipient.ownerAddress);
+        const token = getSolTokenFromTokenName(recipient.tokenName);
+        let tokenAddress;
+        if (recipient.tokenAddress) {
+            tokenAddress = recipient.tokenAddress;
+        }
+        else if (token) {
+            tokenAddress = token.tokenAddress;
+        }
+        if (!tokenAddress) {
+            throw new BuildTransactionError('Invalid token name, got: ' + recipient.tokenName);
+        }
+        validateMintAddress(tokenAddress);
+        this._createAtaParams.push(recipient);
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._sender, 'Sender must be set before building the transaction');
+        const sendInstructions = await Promise.all(this._sendParams.map(async (sendParams) => {
+            if (sendParams.tokenName) {
+                const coin = getSolTokenFromTokenName(sendParams.tokenName);
+                let tokenAddress;
+                let tokenName;
+                let programId;
+                let decimals;
+                if (sendParams.tokenAddress && sendParams.programId && sendParams.decimalPlaces != null) {
+                    tokenName = sendParams.tokenName;
+                    tokenAddress = sendParams.tokenAddress;
+                    decimals = sendParams.decimalPlaces;
+                    programId = sendParams.programId;
+                }
+                else if (coin) {
+                    tokenName = coin.name;
+                    tokenAddress = coin.tokenAddress;
+                    decimals = coin.decimalPlaces;
+                    programId = coin.programId;
+                }
+                else {
+                    throw new Error(`Could not determine token information for ${sendParams.tokenName}`);
+                }
+                const sourceAddress = await getAssociatedTokenAccountAddress(tokenAddress, this._sender, false, programId);
+                return {
+                    type: InstructionBuilderTypes.TokenTransfer,
+                    params: {
+                        fromAddress: this._sender,
+                        toAddress: sendParams.address,
+                        amount: sendParams.amount,
+                        tokenName: tokenName,
+                        sourceAddress: sourceAddress,
+                        tokenAddress: tokenAddress,
+                        programId: programId,
+                        decimalPlaces: decimals,
+                        ...(this._transferHookAccounts ? { transferHookAccounts: this._transferHookAccounts } : {}),
+                    },
+                };
+            }
+            else {
+                return {
+                    type: InstructionBuilderTypes.Transfer,
+                    params: {
+                        fromAddress: this._sender,
+                        toAddress: sendParams.address,
+                        amount: sendParams.amount,
+                    },
+                };
+            }
+        }));
+        const uniqueCreateAtaParams = _.uniqBy(this._createAtaParams, (recipient) => {
+            return recipient.ownerAddress + recipient.tokenName;
+        });
+        const createAtaInstructions = await Promise.all(uniqueCreateAtaParams.map(async (recipient) => {
+            const coin = getSolTokenFromTokenName(recipient.tokenName);
+            let tokenAddress;
+            let tokenName;
+            let programId;
+            if (recipient.tokenAddress && recipient.programId) {
+                tokenName = recipient.tokenName;
+                tokenAddress = recipient.tokenAddress;
+                programId = recipient.programId;
+            }
+            else if (coin) {
+                tokenName = coin.name;
+                tokenAddress = coin.tokenAddress;
+                programId = coin.programId;
+            }
+            else {
+                throw new Error(`Could not determine token information for ${recipient.tokenName}`);
+            }
+            const recipientTokenAddress = await getAssociatedTokenAccountAddress(tokenAddress, recipient.ownerAddress, false, programId);
+            return {
+                type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
+                params: {
+                    ownerAddress: recipient.ownerAddress,
+                    tokenName: tokenName,
+                    mintAddress: tokenAddress,
+                    ataAddress: recipientTokenAddress,
+                    // Match transactionBuilder fee payer selection: when a distinct fee payer
+                    // is set (e.g. gas tank on consolidation), it must fund ATA rent — the
+                    // token sender/authority often has no SOL.
+                    payerAddress: this._feePayer ?? this._sender,
+                    programId: programId,
+                },
+            };
+        }));
+        // When resolved, emit the permissionless thaw between ATA creation and the transfer so the
+        // built order is [CreateATA?, PermissionlessThawIdempotent, TokenTransfer].
+        const thawInstructions = this._permissionlessThaw
+            ? [{ type: InstructionBuilderTypes.PermissionlessThawIdempotent, params: this._permissionlessThaw }]
+            : [];
+        let addPriorityFeeInstruction;
+        // If there are createAtaInstructions, then token is involved and we need to add a priority fee instruction
+        if (!this._priorityFee || this._priorityFee === Number(0)) {
+            this._instructionsData = [...createAtaInstructions, ...thawInstructions, ...sendInstructions];
+        }
+        else if (createAtaInstructions.length !== 0 ||
+            sendInstructions.some((instruction) => instruction.type === InstructionBuilderTypes.TokenTransfer)) {
+            addPriorityFeeInstruction = {
+                type: InstructionBuilderTypes.SetPriorityFee,
+                params: {
+                    fee: this._priorityFee,
+                },
+            };
+            this._instructionsData = [
+                addPriorityFeeInstruction,
+                ...createAtaInstructions,
+                ...thawInstructions,
+                ...sendInstructions,
+            ];
+        }
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferBuilderV2.js","sourceRoot":"","sources":["../../../src/lib/transferBuilderV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE9E,OAAO,EACL,gCAAgC,EAChC,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,SAAS,CAAC;AAEjB,OAAO,MAAM,MAAM,QAAQ,CAAC;AAU5B,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,CAAC,MAAM,QAAQ,CAAC;AAWvB,MAAM,mBAAmB,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAE3D,MAAM,OAAO,iBAAkB,SAAQ,kBAAkB;IAKvD,YAAY,WAAiC;QAC3C,KAAK,CAAC,WAAW,CAAC,CAAC;QALb,gBAAW,GAAiB,EAAE,CAAC;QAMrC,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;IAC7B,CAAC;IAED;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,MAA8C;QAC/D,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,oBAAoB,CAAC,KAAyB;QAC5C,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAc,eAAe;QAC3B,OAAO,eAAe,CAAC,IAAI,CAAC;IAC9B,CAAC;IAED,WAAW,CAAC,EAAe;QACzB,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QAEtB,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACjD,IAAI,WAAW,CAAC,IAAI,KAAK,uBAAuB,CAAC,QAAQ,EAAE,CAAC;gBAC1D,MAAM,mBAAmB,GAAa,WAAW,CAAC;gBAClD,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBACpD,IAAI,CAAC,IAAI,CAAC;oBACR,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,SAAS;oBAC7C,MAAM,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM;iBAC1C,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,WAAW,CAAC,IAAI,KAAK,uBAAuB,CAAC,aAAa,EAAE,CAAC;gBACtE,MAAM,mBAAmB,GAAkB,WAAW,CAAC;gBACvD,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBACpD,IAAI,CAAC,IAAI,CAAC;oBACR,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,SAAS;oBAC7C,MAAM,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM;oBACzC,SAAS,EAAE,mBAAmB,CAAC,MAAM,CAAC,SAAS;iBAChD,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,WAAW,CAAC,IAAI,KAAK,uBAAuB,CAAC,4BAA4B,EAAE,CAAC;gBACrF,MAAM,kBAAkB,GAAY,WAAW,CAAC;gBAChD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC;oBACzB,YAAY,EAAE,kBAAkB,CAAC,MAAM,CAAC,YAAY;oBACpD,SAAS,EAAE,kBAAkB,CAAC,MAAM,CAAC,SAAS;oBAC9C,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,UAAU;iBACjD,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,YAAoB;QAC3B,eAAe,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;QACzC,IAAI,CAAC,SAAS,GAAG,YAAY,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAC,UAAsB;QACzB,eAAe,CAAC,UAAU,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5D,MAAM,IAAI,qBAAqB,CAAC,kCAAkC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;QAC1F,CAAC;QACD,IAAI,UAAU,CAAC,SAAS,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,mBAAmB,EAAE,CAAC;YAC5E,MAAM,IAAI,qBAAqB,CAAC,gBAAgB,UAAU,CAAC,MAAM,0BAA0B,mBAAmB,EAAE,CAAC,CAAC;QACpH,CAAC;aAAM,IAAI,CAAC,UAAU,CAAC,SAAS,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAChG,MAAM,IAAI,qBAAqB,CAC7B,gBAAgB,UAAU,CAAC,MAAM,yBAAyB,MAAM,CAAC,gBAAgB,EAAE,CACpF,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,4BAA4B,CAAC,SAAkC;QAC7D,oBAAoB,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QAC7C,MAAM,KAAK,GAAG,wBAAwB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAC5D,IAAI,YAAY,CAAC;QACjB,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC,YAAY,CAAC;QACxC,CAAC;aAAM,IAAI,KAAK,EAAE,CAAC;YACjB,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QACpC,CAAC;QAED,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,qBAAqB,CAAC,2BAA2B,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;QACrF,CAAC;QACD,mBAAmB,CAAC,YAAY,CAAC,CAAC;QAElC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IACR,KAAK,CAAC,mBAAmB;QACjC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,oDAAoD,CAAC,CAAC;QAC3E,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,GAAG,CACxC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,UAAsB,EAAqC,EAAE;YACvF,IAAI,UAAU,CAAC,SAAS,EAAE,CAAC;gBACzB,MAAM,IAAI,GAAG,wBAAwB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;gBAC5D,IAAI,YAAoB,CAAC;gBACzB,IAAI,SAAiB,CAAC;gBACtB,IAAI,SAA6B,CAAC;gBAClC,IAAI,QAA4B,CAAC;gBACjC,IAAI,UAAU,CAAC,YAAY,IAAI,UAAU,CAAC,SAAS,IAAI,UAAU,CAAC,aAAa,IAAI,IAAI,EAAE,CAAC;oBACxF,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;oBACjC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;oBACvC,QAAQ,GAAG,UAAU,CAAC,aAAa,CAAC;oBACpC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;gBACnC,CAAC;qBAAM,IAAI,IAAI,EAAE,CAAC;oBAChB,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC;oBACtB,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;oBACjC,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC;oBAC9B,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;gBAC7B,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,KAAK,CAAC,6CAA6C,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC;gBACvF,CAAC;gBAED,MAAM,aAAa,GAAG,MAAM,gCAAgC,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;gBAC3G,OAAO;oBACL,IAAI,EAAE,uBAAuB,CAAC,aAAa;oBAC3C,MAAM,EAAE;wBACN,WAAW,EAAE,IAAI,CAAC,OAAO;wBACzB,SAAS,EAAE,UAAU,CAAC,OAAO;wBAC7B,MAAM,EAAE,UAAU,CAAC,MAAM;wBACzB,SAAS,EAAE,SAAS;wBACpB,aAAa,EAAE,aAAa;wBAC5B,YAAY,EAAE,YAAY;wBAC1B,SAAS,EAAE,SAAS;wBACpB,aAAa,EAAE,QAAQ;wBACvB,GAAG,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE,oBAAoB,EAAE,IAAI,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;qBAC5F;iBACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,OAAO;oBACL,IAAI,EAAE,uBAAuB,CAAC,QAAQ;oBACtC,MAAM,EAAE;wBACN,WAAW,EAAE,IAAI,CAAC,OAAO;wBACzB,SAAS,EAAE,UAAU,CAAC,OAAO;wBAC7B,MAAM,EAAE,UAAU,CAAC,MAAM;qBAC1B;iBACF,CAAC;YACJ,CAAC;QACH,CAAC,CAAC,CACH,CAAC;QACF,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,SAAkC,EAAE,EAAE;YACnG,OAAO,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC;QACtD,CAAC,CAAC,CAAC;QACH,MAAM,qBAAqB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC7C,qBAAqB,CAAC,GAAG,CAAC,KAAK,EAAE,SAAkC,EAAoB,EAAE;YACvF,MAAM,IAAI,GAAG,wBAAwB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAC3D,IAAI,YAAoB,CAAC;YACzB,IAAI,SAAiB,CAAC;YACtB,IAAI,SAA6B,CAAC;YAClC,IAAI,SAAS,CAAC,YAAY,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;gBAClD,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC;gBAChC,YAAY,GAAG,SAAS,CAAC,YAAY,CAAC;gBACtC,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC;YAClC,CAAC;iBAAM,IAAI,IAAI,EAAE,CAAC;gBAChB,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC;gBACtB,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;gBACjC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;YAC7B,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,6CAA6C,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC;YACtF,CAAC;YACD,MAAM,qBAAqB,GAAG,MAAM,gCAAgC,CAClE,YAAY,EACZ,SAAS,CAAC,YAAY,EACtB,KAAK,EACL,SAAS,CACV,CAAC;YACF,OAAO;gBACL,IAAI,EAAE,uBAAuB,CAAC,4BAA4B;gBAC1D,MAAM,EAAE;oBACN,YAAY,EAAE,SAAS,CAAC,YAAY;oBACpC,SAAS,EAAE,SAAS;oBACpB,WAAW,EAAE,YAAY;oBACzB,UAAU,EAAE,qBAAqB;oBACjC,0EAA0E;oBAC1E,uEAAuE;oBACvE,2CAA2C;oBAC3C,YAAY,EAAE,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO;oBAC5C,SAAS,EAAE,SAAS;iBACrB;aACF,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;QAEF,2FAA2F;QAC3F,4EAA4E;QAC5E,MAAM,gBAAgB,GAAmC,IAAI,CAAC,mBAAmB;YAC/E,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,uBAAuB,CAAC,4BAA4B,EAAE,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACpG,CAAC,CAAC,EAAE,CAAC;QAEP,IAAI,yBAAyC,CAAC;QAC9C,2GAA2G;QAC3G,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1D,IAAI,CAAC,iBAAiB,GAAG,CAAC,GAAG,qBAAqB,EAAE,GAAG,gBAAgB,EAAE,GAAG,gBAAgB,CAAC,CAAC;QAChG,CAAC;aAAM,IACL,qBAAqB,CAAC,MAAM,KAAK,CAAC;YAClC,gBAAgB,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,KAAK,uBAAuB,CAAC,aAAa,CAAC,EAClG,CAAC;YACD,yBAAyB,GAAG;gBAC1B,IAAI,EAAE,uBAAuB,CAAC,cAAc;gBAC5C,MAAM,EAAE;oBACN,GAAG,EAAE,IAAI,CAAC,YAAY;iBACvB;aACF,CAAC;YACF,IAAI,CAAC,iBAAiB,GAAG;gBACvB,yBAAyB;gBACzB,GAAG,qBAAqB;gBACxB,GAAG,gBAAgB;gBACnB,GAAG,gBAAgB;aACpB,CAAC;QACJ,CAAC;QAED,OAAO,MAAM,KAAK,CAAC,mBAAmB,EAAE,CAAC;IAC3C,CAAC;CACF","sourcesContent":["import { TransactionBuilder } from './transactionBuilder';\nimport { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport {\n  getAssociatedTokenAccountAddress,\n  getSolTokenFromTokenName,\n  isValidAmount,\n  validateAddress,\n  validateMintAddress,\n  validateOwnerAddress,\n} from './utils';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport assert from 'assert';\nimport {\n  AtaInit,\n  ExtraAccountMeta,\n  PermissionlessThawIdempotent,\n  TokenAssociateRecipient,\n  TokenTransfer,\n  Transfer,\n  SetPriorityFee,\n} from './iface';\nimport { InstructionBuilderTypes } from './constants';\nimport _ from 'lodash';\n\nexport interface SendParams {\n  address: string;\n  amount: string;\n  tokenName?: string;\n  tokenAddress?: string;\n  programId?: string;\n  decimalPlaces?: number;\n}\n\nconst UNSIGNED_BIGINT_MAX = BigInt('18446744073709551615');\n\nexport class TransferBuilderV2 extends TransactionBuilder {\n  private _sendParams: SendParams[] = [];\n  private _createAtaParams: TokenAssociateRecipient[];\n  private _transferHookAccounts?: ExtraAccountMeta[];\n  private _permissionlessThaw?: PermissionlessThawIdempotent['params'];\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._createAtaParams = [];\n  }\n\n  /**\n   * Set the resolved sRFC-37 Token ACL permissionless-thaw params for this transfer.\n   *\n   * These must be resolved live by the caller (e.g. via `Sol.resolvePermissionlessThaw`) since\n   * builders remain offline and never perform RPC. When set, the built transaction bundles a\n   * `PermissionlessThawIdempotent` instruction after any ATA creation and before the transfer, so\n   * a freshly created (frozen) allowlist/blocklist token account is thawed atomically with the\n   * transfer — all-or-nothing.\n   *\n   * @param {PermissionlessThawIdempotent['params']} params - resolved thaw params\n   * @returns {TransferBuilderV2} This transaction builder\n   */\n  permissionlessThaw(params: PermissionlessThawIdempotent['params']): this {\n    this._permissionlessThaw = params;\n    return this;\n  }\n\n  /**\n   * Set the resolved Token-2022 Transfer Hook extra account metas for this transfer.\n   *\n   * These must be resolved live by the caller (e.g. via `Sol.resolveTransferHookAccounts`)\n   * since builders remain offline and never perform RPC. The order is significant and\n   * must match the hook's ExtraAccountMetaList.\n   *\n   * @param {ExtraAccountMeta[]} metas - resolved extra account metas, in hook order\n   * @returns {TransferBuilderV2} This transaction builder\n   */\n  transferHookAccounts(metas: ExtraAccountMeta[]): this {\n    this._transferHookAccounts = metas;\n    return this;\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Send;\n  }\n\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n\n    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.Transfer) {\n        const transferInstruction: Transfer = instruction;\n        this.sender(transferInstruction.params.fromAddress);\n        this.send({\n          address: transferInstruction.params.toAddress,\n          amount: transferInstruction.params.amount,\n        });\n      } else if (instruction.type === InstructionBuilderTypes.TokenTransfer) {\n        const transferInstruction: TokenTransfer = instruction;\n        this.sender(transferInstruction.params.fromAddress);\n        this.send({\n          address: transferInstruction.params.toAddress,\n          amount: transferInstruction.params.amount,\n          tokenName: transferInstruction.params.tokenName,\n        });\n      } else if (instruction.type === InstructionBuilderTypes.CreateAssociatedTokenAccount) {\n        const ataInitInstruction: AtaInit = instruction;\n        this._createAtaParams.push({\n          ownerAddress: ataInitInstruction.params.ownerAddress,\n          tokenName: ataInitInstruction.params.tokenName,\n          ataAddress: ataInitInstruction.params.ataAddress,\n        });\n      }\n    }\n  }\n\n  /**\n   * Set a feePayer\n   * @param payerAddress\n   */\n  feePayer(payerAddress: string): this {\n    validateAddress(payerAddress, 'address');\n    this._feePayer = payerAddress;\n    return this;\n  }\n\n  /**\n   *  Set a transfer\n   *\n   * @param {SendParams} sendParams - sendParams\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  send(sendParams: SendParams): this {\n    validateAddress(sendParams.address, 'address');\n    if (!sendParams.amount || !isValidAmount(sendParams.amount)) {\n      throw new BuildTransactionError('Invalid or missing amount, got: ' + sendParams.amount);\n    }\n    if (sendParams.tokenName && BigInt(sendParams.amount) > UNSIGNED_BIGINT_MAX) {\n      throw new BuildTransactionError(`input amount ${sendParams.amount} exceeds big int limit ${UNSIGNED_BIGINT_MAX}`);\n    } else if (!sendParams.tokenName && BigInt(sendParams.amount) > BigInt(Number.MAX_SAFE_INTEGER)) {\n      throw new BuildTransactionError(\n        `input amount ${sendParams.amount} exceeds max safe int ${Number.MAX_SAFE_INTEGER}`\n      );\n    }\n\n    this._sendParams.push(sendParams);\n    return this;\n  }\n\n  /**\n   *\n   * @param {TokenAssociateRecipient} recipient - recipient of the associated token account creation\n   * @param {string} recipient.ownerAddress - owner of the associated token account\n   * @param {string} recipient.tokenName - name of the token that is intended to associate\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  createAssociatedTokenAccount(recipient: TokenAssociateRecipient): this {\n    validateOwnerAddress(recipient.ownerAddress);\n    const token = getSolTokenFromTokenName(recipient.tokenName);\n    let tokenAddress;\n    if (recipient.tokenAddress) {\n      tokenAddress = recipient.tokenAddress;\n    } else if (token) {\n      tokenAddress = token.tokenAddress;\n    }\n\n    if (!tokenAddress) {\n      throw new BuildTransactionError('Invalid token name, got: ' + recipient.tokenName);\n    }\n    validateMintAddress(tokenAddress);\n\n    this._createAtaParams.push(recipient);\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._sender, 'Sender must be set before building the transaction');\n    const sendInstructions = await Promise.all(\n      this._sendParams.map(async (sendParams: SendParams): Promise<Transfer | TokenTransfer> => {\n        if (sendParams.tokenName) {\n          const coin = getSolTokenFromTokenName(sendParams.tokenName);\n          let tokenAddress: string;\n          let tokenName: string;\n          let programId: string | undefined;\n          let decimals: number | undefined;\n          if (sendParams.tokenAddress && sendParams.programId && sendParams.decimalPlaces != null) {\n            tokenName = sendParams.tokenName;\n            tokenAddress = sendParams.tokenAddress;\n            decimals = sendParams.decimalPlaces;\n            programId = sendParams.programId;\n          } else if (coin) {\n            tokenName = coin.name;\n            tokenAddress = coin.tokenAddress;\n            decimals = coin.decimalPlaces;\n            programId = coin.programId;\n          } else {\n            throw new Error(`Could not determine token information for ${sendParams.tokenName}`);\n          }\n\n          const sourceAddress = await getAssociatedTokenAccountAddress(tokenAddress, this._sender, false, programId);\n          return {\n            type: InstructionBuilderTypes.TokenTransfer,\n            params: {\n              fromAddress: this._sender,\n              toAddress: sendParams.address,\n              amount: sendParams.amount,\n              tokenName: tokenName,\n              sourceAddress: sourceAddress,\n              tokenAddress: tokenAddress,\n              programId: programId,\n              decimalPlaces: decimals,\n              ...(this._transferHookAccounts ? { transferHookAccounts: this._transferHookAccounts } : {}),\n            },\n          };\n        } else {\n          return {\n            type: InstructionBuilderTypes.Transfer,\n            params: {\n              fromAddress: this._sender,\n              toAddress: sendParams.address,\n              amount: sendParams.amount,\n            },\n          };\n        }\n      })\n    );\n    const uniqueCreateAtaParams = _.uniqBy(this._createAtaParams, (recipient: TokenAssociateRecipient) => {\n      return recipient.ownerAddress + recipient.tokenName;\n    });\n    const createAtaInstructions = await Promise.all(\n      uniqueCreateAtaParams.map(async (recipient: TokenAssociateRecipient): Promise<AtaInit> => {\n        const coin = getSolTokenFromTokenName(recipient.tokenName);\n        let tokenAddress: string;\n        let tokenName: string;\n        let programId: string | undefined;\n        if (recipient.tokenAddress && recipient.programId) {\n          tokenName = recipient.tokenName;\n          tokenAddress = recipient.tokenAddress;\n          programId = recipient.programId;\n        } else if (coin) {\n          tokenName = coin.name;\n          tokenAddress = coin.tokenAddress;\n          programId = coin.programId;\n        } else {\n          throw new Error(`Could not determine token information for ${recipient.tokenName}`);\n        }\n        const recipientTokenAddress = await getAssociatedTokenAccountAddress(\n          tokenAddress,\n          recipient.ownerAddress,\n          false,\n          programId\n        );\n        return {\n          type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n          params: {\n            ownerAddress: recipient.ownerAddress,\n            tokenName: tokenName,\n            mintAddress: tokenAddress,\n            ataAddress: recipientTokenAddress,\n            // Match transactionBuilder fee payer selection: when a distinct fee payer\n            // is set (e.g. gas tank on consolidation), it must fund ATA rent — the\n            // token sender/authority often has no SOL.\n            payerAddress: this._feePayer ?? this._sender,\n            programId: programId,\n          },\n        };\n      })\n    );\n\n    // When resolved, emit the permissionless thaw between ATA creation and the transfer so the\n    // built order is [CreateATA?, PermissionlessThawIdempotent, TokenTransfer].\n    const thawInstructions: PermissionlessThawIdempotent[] = this._permissionlessThaw\n      ? [{ type: InstructionBuilderTypes.PermissionlessThawIdempotent, params: this._permissionlessThaw }]\n      : [];\n\n    let addPriorityFeeInstruction: SetPriorityFee;\n    // If there are createAtaInstructions, then token is involved and we need to add a priority fee instruction\n    if (!this._priorityFee || this._priorityFee === Number(0)) {\n      this._instructionsData = [...createAtaInstructions, ...thawInstructions, ...sendInstructions];\n    } else if (\n      createAtaInstructions.length !== 0 ||\n      sendInstructions.some((instruction) => instruction.type === InstructionBuilderTypes.TokenTransfer)\n    ) {\n      addPriorityFeeInstruction = {\n        type: InstructionBuilderTypes.SetPriorityFee,\n        params: {\n          fee: this._priorityFee,\n        },\n      };\n      this._instructionsData = [\n        addPriorityFeeInstruction,\n        ...createAtaInstructions,\n        ...thawInstructions,\n        ...sendInstructions,\n      ];\n    }\n\n    return await super.buildImplementation();\n  }\n}\n"]}

package/dist/esm/lib/utils.d.ts

@@ -0,0 +1,205 @@
+import { SolInstruction, SolVersionedInstruction, TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin, BaseNetwork, SolCoin } from '@bitgo-beta/statics';
+import { SignaturePubkeyPair, Transaction as SolTransaction, TransactionInstruction } from '@solana/web3.js';
+import { ValidInstructionTypes } from './iface';
+/**
+ * Checks if an ATA instruction is idempotent (discriminator byte = 1).
+ *
+ * Idempotent ATA instructions use Buffer.from([1]) as instruction data, created by
+ * @solana/spl-token's createAssociatedTokenAccountIdempotentInstruction() (v0.4.1+).
+ * An idempotent ATA instruction succeed even if account exists,
+ * preventing race condition errors in concurrent scenarios.
+ *
+ * @param {TransactionInstruction} instruction - The instruction to validate
+ * @returns {boolean} True if instruction data is a single byte with value 1
+ */
+export declare function isIdempotentAtaInstruction(instruction: TransactionInstruction): boolean;
+/** @inheritdoc */
+export declare function isValidAddress(address: string): boolean;
+/** @inheritdoc */
+export declare function isValidBlockId(hash: string): boolean;
+/** @inheritdoc */
+export declare function isValidPrivateKey(prvKey: string | Uint8Array): boolean;
+/** @inheritdoc */
+export declare function isValidPublicKey(pubKey: string): boolean;
+/** @inheritdoc */
+export declare function isValidSignature(signature: string): boolean;
+/** @inheritdoc */
+export declare function isValidTransactionId(txId: string): boolean;
+/**
+ * Returns whether or not the string is a valid amount of lamports number
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidAmount(amount: string): boolean;
+/**
+ * Check if the string is a valid amount of lamports number on staking
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidStakingAmount(amount: string): boolean;
+/**
+ * Check if this is a valid memo or not.
+ *
+ * @param memo - the memo string
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidMemo(memo: string): boolean;
+/**
+ * Checks if a string is valid base64 encoded data
+ * @param str - The string to validate
+ * @returns True if the string is valid base64, false otherwise
+ */
+export declare function isValidBase64(str: string): boolean;
+/**
+ * Checks if a string is valid hexadecimal data
+ * @param str - The string to validate
+ * @returns True if the string is valid hex, false otherwise
+ */
+export declare function isValidHex(str: string): boolean;
+/**
+ * Checks if raw transaction can be deserialized
+ *
+ * @param {string} rawTransaction - transaction in base64 string format
+ * @param {boolean} requireAllSignatures - require all signatures to be present
+ * @param {boolean} verifySignatures - verify signatures
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidRawTransaction(rawTransaction: string, requireAllSignatures?: boolean, verifySignatures?: boolean): boolean;
+/**
+ * Verifies if signature for message is valid.
+ *
+ * @param {Buffer} serializedTx - tx as a base64 string
+ * @param {string} signature - signature as a string
+ * @param {string} publicKey - public key as base 58
+ * @returns {Boolean} true if signature is valid.
+ */
+export declare function verifySignature(serializedTx: string, signature: string, publicKey: string): boolean;
+/**
+ * Converts a base58 string into a Uint8Array.
+ *
+ * @param {string} input - a string in base58
+ * @returns {Uint8Array} - an Uint8Array
+ */
+export declare function base58ToUint8Array(input: string): Uint8Array;
+/**
+ * Converts a Uint8Array to a base58 string.
+ *
+ * @param {Uint8Array} input - an Uint8Array
+ * @returns {string} - a string in base58
+ */
+export declare function Uint8ArrayTobase58(input: Uint8Array): string;
+/**
+ * Count the amount of signatures are not null.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - an array of SignaturePubkeyPair
+ * @returns {number} - the amount of valid signatures
+ */
+export declare function countNotNullSignatures(signatures: SignaturePubkeyPair[]): number;
+/**
+ * Check if all signatures are completed.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - signatures
+ * @returns {boolean}
+ */
+export declare function requiresAllSignatures(signatures: SignaturePubkeyPair[]): boolean;
+/**
+ * Check the transaction type matching instructions by order. Memo and AdvanceNonceAccount instructions
+ * are ignored.
+ *
+ * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed
+ * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction
+ * @returns true if it matches by order.
+ */
+export declare function matchTransactionTypeByInstructionsOrder(instructions: TransactionInstruction[], instructionIndexes: Record<string, number>): boolean;
+/**
+ * Returns the transaction Type based on the  transaction instructions.
+ * Wallet initialization, Transfer and Staking transactions are supported.
+ *
+ * @param {SolTransaction} transaction - the solana transaction
+ * @returns {TransactionType} - the type of transaction
+ */
+export declare function getTransactionType(transaction: SolTransaction): TransactionType;
+/**
+ * Returns the instruction Type based on the solana instructions.
+ * Throws if the solana instruction program is not supported
+ *
+ * @param {TransactionInstruction} instruction - a solana instruction
+ * @returns {ValidInstructionTypes} - a solana instruction type
+ */
+export declare function getInstructionType(instruction: TransactionInstruction): ValidInstructionTypes;
+/**
+ * Validate solana instructions types to see if they are supported by the builder.
+ * Throws if the instruction type is invalid.
+ *
+ * @param {TransactionInstruction} instructions - a solana instruction
+ * @returns {void}
+ */
+export declare function validateIntructionTypes(instructions: TransactionInstruction[]): void;
+/**
+ * Validate solana instructions match raw msg authorize transaction
+ *
+ * @param {TransactionInstruction} instructions - a solana instruction
+ * @returns {boolean} true if the instructions match the raw msg authorize transaction
+ */
+export declare function validateRawMsgInstruction(instructions: TransactionInstruction[]): boolean;
+/**
+ * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+ *
+ * @param {string} rawTransaction - Transaction in base64 string  format
+ */
+export declare function validateRawTransaction(rawTransaction: string, requireAllSignatures?: boolean, verifySignatures?: boolean): void;
+/**
+ * Validates address to check if it exists and is a valid Solana public key
+ *
+ * @param {string} address The address to be validated
+ * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.
+ */
+export declare function validateAddress(address: string, fieldName: string): void;
+/**
+ * Get the statics coin object matching a given Solana token address if it exists
+ *
+ * @param tokenAddress The token address to match against
+ * @param network Solana Mainnet or Testnet
+ * @returns statics BaseCoin object for the matching token
+ */
+export declare function getSolTokenFromAddress(tokenAddress: string, network: BaseNetwork): Readonly<BaseCoin> | undefined;
+/**
+ * Get the statics coin object matching a given Solana token address if it exists
+ *
+ * @param tokenAddress The token address to match against
+ * @param network Solana Mainnet or Testnet
+ * @returns statics BaseCoin object for the matching token
+ */
+export declare function getSolTokenFromAddressOnly(tokenAddress: string): Readonly<BaseCoin> | undefined;
+/**
+ * Get the solana token object from token name
+ * @param tokenName The token name to match against
+ * */
+export declare function getSolTokenFromTokenName(tokenName: string): Readonly<SolCoin> | undefined;
+/**
+ * Get the solana associated token account address
+ * @param tokenAddress token mint address
+ * @param ownerAddress The owner of the associated token account
+ * @returns The associated token account address
+ * */
+export declare function getAssociatedTokenAccountAddress(tokenMintAddress: string, ownerAddress: string, allowOwnerOffCurve?: boolean, programId?: string): Promise<string>;
+export declare function validateMintAddress(mintAddress: string): void;
+export declare function validateOwnerAddress(ownerAddress: string): void;
+/**
+ * Type predicate to check if an instruction is a legacy SolInstruction.
+ * Uses 'programId' property as the discriminator since it's unique to legacy instructions
+ * Versioned instructions have 'programIdIndex' property.
+ *
+ * @param instruction - The instruction to check
+ * @returns True if the instruction is a SolInstruction (has programId field)
+ */
+export declare function isSolLegacyInstruction(instruction: SolInstruction | SolVersionedInstruction): instruction is SolInstruction;
+/**
+ * Token-2022 transfer fee: min(amount * basisPoints / 10000, maximumFee), in raw base units.
+ * All math in BigInt to avoid precision loss.
+ */
+export declare function computeTransferFee(amount: string, basisPoints: number, maximumFee: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/{src → esm}/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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"}