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

package/dist/cjs/src/lib/tokenExtensions.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionTypeNames = extensionTypeNames;
+exports.mapModeledExtensions = mapModeledExtensions;
+exports.assertExtensionCompatibility = assertExtensionCompatibility;
+exports.parseMintExtensions = parseMintExtensions;
+exports.readMintExtensions = readMintExtensions;
+const statics_1 = require("@bitgo-beta/statics");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+/** Map from `@solana/spl-token` ExtensionType names to BitGo's modeled extension types. */
+const EXTENSION_NAME_MAP = {
+    TransferFeeConfig: statics_1.SolTokenExtensionType.TransferFee,
+    TransferHook: statics_1.SolTokenExtensionType.TransferHook,
+    PermanentDelegate: statics_1.SolTokenExtensionType.PermanentDelegate,
+    InterestBearingConfig: statics_1.SolTokenExtensionType.InterestBearing,
+    DefaultAccountState: statics_1.SolTokenExtensionType.DefaultAccountState,
+    ScaledUiAmountConfig: statics_1.SolTokenExtensionType.ScaledUiAmount,
+};
+const CONFIDENTIAL_TRANSFER_NAMES = ['ConfidentialTransferMint', 'ConfidentialTransferFeeConfig'];
+/** Human-readable names of every extension type present on the mint. */
+function extensionTypeNames(mintInfo) {
+    if (mintInfo.tlvData.length === 0) {
+        return [];
+    }
+    return (0, spl_token_1.getExtensionTypes)(mintInfo.tlvData).map((t) => spl_token_1.ExtensionType[t] ?? `unknown(${t})`);
+}
+/** The subset of detected extensions that BitGo models. Pure — unit-testable without chain data. */
+function mapModeledExtensions(detectedTypeNames) {
+    const modeled = [];
+    for (const name of detectedTypeNames) {
+        const mapped = EXTENSION_NAME_MAP[name];
+        if (mapped !== undefined && !modeled.includes(mapped)) {
+            modeled.push(mapped);
+        }
+    }
+    return modeled;
+}
+/**
+ * Enforce the protocol-level incompatibility: Transfer Hook and Confidential
+ * Transfer cannot coexist on the same mint. Pure — unit-testable without chain data.
+ */
+function assertExtensionCompatibility(detectedTypeNames) {
+    const hasHook = detectedTypeNames.includes('TransferHook');
+    const hasConfidential = detectedTypeNames.some((n) => CONFIDENTIAL_TRANSFER_NAMES.includes(n));
+    if (hasHook && hasConfidential) {
+        throw new Error('Mint declares both Transfer Hook and Confidential Transfer, which cannot coexist');
+    }
+}
+function toBase58(key) {
+    return key ? key.toBase58() : undefined;
+}
+/**
+ * Parse a decoded Token-2022 `Mint` into BitGo's extension model. Separated from the RPC call
+ * so it can be unit-tested against recorded mint fixtures.
+ */
+function parseMintExtensions(mintInfo) {
+    const detectedTypeNames = extensionTypeNames(mintInfo);
+    assertExtensionCompatibility(detectedTypeNames);
+    const extensions = { detected: mapModeledExtensions(detectedTypeNames) };
+    const authorities = {
+        mintAuthority: toBase58(mintInfo.mintAuthority),
+        freezeAuthority: toBase58(mintInfo.freezeAuthority),
+    };
+    const feeConfig = (0, spl_token_1.getTransferFeeConfig)(mintInfo);
+    if (feeConfig) {
+        extensions.transferFee = {
+            transferFeeBasisPoints: feeConfig.newerTransferFee.transferFeeBasisPoints,
+            maximumFee: feeConfig.newerTransferFee.maximumFee.toString(),
+        };
+        authorities.transferFeeConfigAuthority = toBase58(feeConfig.transferFeeConfigAuthority);
+        authorities.withdrawWithheldAuthority = toBase58(feeConfig.withdrawWithheldAuthority);
+    }
+    const hook = (0, spl_token_1.getTransferHook)(mintInfo);
+    if (hook) {
+        extensions.transferHookProgramId = hook.programId.toBase58();
+    }
+    const delegate = (0, spl_token_1.getPermanentDelegate)(mintInfo);
+    if (delegate?.delegate) {
+        authorities.permanentDelegate = delegate.delegate.toBase58();
+    }
+    const interest = (0, spl_token_1.getInterestBearingMintConfigState)(mintInfo);
+    if (interest) {
+        extensions.interestBearing = { rateBasisPoints: interest.currentRate };
+        authorities.rateAuthority = toBase58(interest.rateAuthority);
+    }
+    // DefaultAccountState is a single byte (AccountState). Decoded generically to avoid depending
+    // on a version-specific typed getter. permissionlessThaw is NOT on-chain — resolved separately
+    // at onboarding; defaults false until confirmed.
+    const defaultStateData = (0, spl_token_1.getExtensionData)(spl_token_1.ExtensionType.DefaultAccountState, mintInfo.tlvData);
+    if (defaultStateData) {
+        extensions.defaultAccountState = {
+            frozen: defaultStateData[0] === spl_token_1.AccountState.Frozen,
+            permissionlessThaw: false,
+        };
+    }
+    // NOTE: ScaledUiAmount config parsing (initialMultiplier) is intentionally deferred — the typed
+    // getter is not available in @solana/spl-token@0.4.9. The extension is still *detected* above
+    // (so the safety gate sees it); populating scaledUiAmount.initialMultiplier is a follow-up that
+    // bumps @solana/spl-token to a version exposing getScaledUiAmountConfig. See PR for 3.4.
+    if (Object.values(authorities).some((v) => v !== undefined)) {
+        extensions.authorities = authorities;
+    }
+    return { detectedTypeNames, extensions };
+}
+/** Fetch a Token-2022 mint and parse its extensions. Uses `finalized` commitment rules. */
+async function readMintExtensions(connection, mint, commitment = 'finalized') {
+    const mintPubkey = typeof mint === 'string' ? new web3_js_1.PublicKey(mint) : mint;
+    const mintInfo = await (0, spl_token_1.getMint)(connection, mintPubkey, commitment, spl_token_1.TOKEN_2022_PROGRAM_ID);
+    return parseMintExtensions(mintInfo);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenExtensions.js","sourceRoot":"","sources":["../../../../src/lib/tokenExtensions.ts"],"names":[],"mappings":"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","sourcesContent":["import { SolTokenExtensions, SolTokenExtensionType } from '@bitgo-beta/statics';\nimport {\n  AccountState,\n  ExtensionType,\n  getExtensionData,\n  getExtensionTypes,\n  getInterestBearingMintConfigState,\n  getMint,\n  getPermanentDelegate,\n  getTransferFeeConfig,\n  getTransferHook,\n  type Mint,\n  TOKEN_2022_PROGRAM_ID,\n} from '@solana/spl-token';\nimport { Commitment, Connection, PublicKey } from '@solana/web3.js';\n\n/**\n * Result of reading a Token-2022 mint's extension data.\n *\n * `detectedTypeNames` lists EVERY extension present on the mint — including ones BitGo does\n * not model — so callers can run the onboarding safety gate (`getUnsupportedSolTokenExtensions`).\n * `extensions` is the typed, storable config for the extensions BitGo does model.\n */\nexport interface MintExtensionReadResult {\n  detectedTypeNames: string[];\n  extensions: SolTokenExtensions;\n}\n\n/** Map from `@solana/spl-token` ExtensionType names to BitGo's modeled extension types. */\nconst EXTENSION_NAME_MAP: Readonly<Record<string, SolTokenExtensionType>> = {\n  TransferFeeConfig: SolTokenExtensionType.TransferFee,\n  TransferHook: SolTokenExtensionType.TransferHook,\n  PermanentDelegate: SolTokenExtensionType.PermanentDelegate,\n  InterestBearingConfig: SolTokenExtensionType.InterestBearing,\n  DefaultAccountState: SolTokenExtensionType.DefaultAccountState,\n  ScaledUiAmountConfig: SolTokenExtensionType.ScaledUiAmount,\n};\n\nconst CONFIDENTIAL_TRANSFER_NAMES = ['ConfidentialTransferMint', 'ConfidentialTransferFeeConfig'];\n\n/** Human-readable names of every extension type present on the mint. */\nexport function extensionTypeNames(mintInfo: Mint): string[] {\n  if (mintInfo.tlvData.length === 0) {\n    return [];\n  }\n  return getExtensionTypes(mintInfo.tlvData).map((t) => ExtensionType[t] ?? `unknown(${t})`);\n}\n\n/** The subset of detected extensions that BitGo models. Pure — unit-testable without chain data. */\nexport function mapModeledExtensions(detectedTypeNames: readonly string[]): SolTokenExtensionType[] {\n  const modeled: SolTokenExtensionType[] = [];\n  for (const name of detectedTypeNames) {\n    const mapped = EXTENSION_NAME_MAP[name];\n    if (mapped !== undefined && !modeled.includes(mapped)) {\n      modeled.push(mapped);\n    }\n  }\n  return modeled;\n}\n\n/**\n * Enforce the protocol-level incompatibility: Transfer Hook and Confidential\n * Transfer cannot coexist on the same mint. Pure — unit-testable without chain data.\n */\nexport function assertExtensionCompatibility(detectedTypeNames: readonly string[]): void {\n  const hasHook = detectedTypeNames.includes('TransferHook');\n  const hasConfidential = detectedTypeNames.some((n) => CONFIDENTIAL_TRANSFER_NAMES.includes(n));\n  if (hasHook && hasConfidential) {\n    throw new Error('Mint declares both Transfer Hook and Confidential Transfer, which cannot coexist');\n  }\n}\n\nfunction toBase58(key: PublicKey | null): string | undefined {\n  return key ? key.toBase58() : undefined;\n}\n\n/**\n * Parse a decoded Token-2022 `Mint` into BitGo's extension model. Separated from the RPC call\n * so it can be unit-tested against recorded mint fixtures.\n */\nexport function parseMintExtensions(mintInfo: Mint): MintExtensionReadResult {\n  const detectedTypeNames = extensionTypeNames(mintInfo);\n  assertExtensionCompatibility(detectedTypeNames);\n\n  const extensions: SolTokenExtensions = { detected: mapModeledExtensions(detectedTypeNames) };\n  const authorities: NonNullable<SolTokenExtensions['authorities']> = {\n    mintAuthority: toBase58(mintInfo.mintAuthority),\n    freezeAuthority: toBase58(mintInfo.freezeAuthority),\n  };\n\n  const feeConfig = getTransferFeeConfig(mintInfo);\n  if (feeConfig) {\n    extensions.transferFee = {\n      transferFeeBasisPoints: feeConfig.newerTransferFee.transferFeeBasisPoints,\n      maximumFee: feeConfig.newerTransferFee.maximumFee.toString(),\n    };\n    authorities.transferFeeConfigAuthority = toBase58(feeConfig.transferFeeConfigAuthority);\n    authorities.withdrawWithheldAuthority = toBase58(feeConfig.withdrawWithheldAuthority);\n  }\n\n  const hook = getTransferHook(mintInfo);\n  if (hook) {\n    extensions.transferHookProgramId = hook.programId.toBase58();\n  }\n\n  const delegate = getPermanentDelegate(mintInfo);\n  if (delegate?.delegate) {\n    authorities.permanentDelegate = delegate.delegate.toBase58();\n  }\n\n  const interest = getInterestBearingMintConfigState(mintInfo);\n  if (interest) {\n    extensions.interestBearing = { rateBasisPoints: interest.currentRate };\n    authorities.rateAuthority = toBase58(interest.rateAuthority);\n  }\n\n  // DefaultAccountState is a single byte (AccountState). Decoded generically to avoid depending\n  // on a version-specific typed getter. permissionlessThaw is NOT on-chain — resolved separately\n  // at onboarding; defaults false until confirmed.\n  const defaultStateData = getExtensionData(ExtensionType.DefaultAccountState, mintInfo.tlvData);\n  if (defaultStateData) {\n    extensions.defaultAccountState = {\n      frozen: defaultStateData[0] === AccountState.Frozen,\n      permissionlessThaw: false,\n    };\n  }\n\n  // NOTE: ScaledUiAmount config parsing (initialMultiplier) is intentionally deferred — the typed\n  // getter is not available in @solana/spl-token@0.4.9. The extension is still *detected* above\n  // (so the safety gate sees it); populating scaledUiAmount.initialMultiplier is a follow-up that\n  // bumps @solana/spl-token to a version exposing getScaledUiAmountConfig. See PR for 3.4.\n\n  if (Object.values(authorities).some((v) => v !== undefined)) {\n    extensions.authorities = authorities;\n  }\n\n  return { detectedTypeNames, extensions };\n}\n\n/** Fetch a Token-2022 mint and parse its extensions. Uses `finalized` commitment rules. */\nexport async function readMintExtensions(\n  connection: Connection,\n  mint: string | PublicKey,\n  commitment: Commitment = 'finalized'\n): Promise<MintExtensionReadResult> {\n  const mintPubkey = typeof mint === 'string' ? new PublicKey(mint) : mint;\n  const mintInfo = await getMint(connection, mintPubkey, commitment, TOKEN_2022_PROGRAM_ID);\n  return parseMintExtensions(mintInfo);\n}\n"]}

package/dist/{src → cjs/src}/lib/tokenTransferBuilder.d.ts

@@ -1,7 +1,7 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import { TransactionType } from '@bitgo-beta/sdk-core';
 import { Transaction } from './transaction';
-import { TokenAssociateRecipient } from './iface';
+import { ExtraAccountMeta, PermissionlessThawIdempotent, TokenAssociateRecipient } from './iface';
 import { TransactionBuilder } from './transactionBuilder';
 export interface SendParams {
     address: string;
@@ -14,7 +14,33 @@ export interface SendParams {
 export declare class TokenTransferBuilder extends TransactionBuilder {
     private _sendParams;
     private _createAtaParams;
+    private _transferHookAccounts?;
+    private _permissionlessThaw?;
     constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * 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 {TokenTransferBuilder} This transaction builder
+     */
+    permissionlessThaw(params: PermissionlessThawIdempotent['params']): 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 {TokenTransferBuilder} This transaction builder
+     */
+    transferHookAccounts(metas: ExtraAccountMeta[]): this;
     protected get transactionType(): TransactionType;
     initBuilder(tx: Transaction): void;
     /**

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenTransferBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/tokenTransferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAU5C,OAAO,EAEL,gBAAgB,EAChB,4BAA4B,EAC5B,uBAAuB,EAGxB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID,qBAAa,oBAAqB,SAAQ,kBAAkB;IAC1D,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,qBAAqB,CAAC,CAAqB;IACnD,OAAO,CAAC,mBAAmB,CAAC,CAAyC;gBAEzD,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,MAAM,EAAE,4BAA4B,CAAC,QAAQ,CAAC,GAAG,IAAI;IAKxE;;;;;;;;;OASG;IACH,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,IAAI;IAKrD,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA6BlC;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,EAAE,UAAU,GAAG,IAAI;IAa9F;;;;;;OAMG;IACH,4BAA4B,CAAC,SAAS,EAAE,uBAAuB,GAAG,IAAI;IAmBtE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CA8G5D"}

package/dist/cjs/src/lib/tokenTransferBuilder.js

@@ -0,0 +1,237 @@
+"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 sdk_core_1 = require("@bitgo-beta/sdk-core");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const assert_1 = __importDefault(require("assert"));
+const transactionBuilder_1 = require("./transactionBuilder");
+const lodash_1 = __importDefault(require("lodash"));
+const UNSIGNED_BIGINT_MAX = BigInt('18446744073709551615');
+class TokenTransferBuilder extends transactionBuilder_1.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 {TokenTransferBuilder} 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 {TokenTransferBuilder} This transaction builder
+     */
+    transferHookAccounts(metas) {
+        this._transferHookAccounts = metas;
+        return this;
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === constants_1.InstructionBuilderTypes.TokenTransfer) {
+                const transferInstruction = instruction;
+                this.sender(transferInstruction.params.fromAddress);
+                this.send({
+                    address: transferInstruction.params.toAddress,
+                    amount: transferInstruction.params.amount,
+                    tokenName: transferInstruction.params.tokenName,
+                    tokenAddress: transferInstruction.params.tokenAddress,
+                    programId: transferInstruction.params.programId,
+                    decimalPlaces: transferInstruction.params.decimalPlaces,
+                });
+            }
+            if (instruction.type === constants_1.InstructionBuilderTypes.CreateAssociatedTokenAccount) {
+                const ataInitInstruction = instruction;
+                this._createAtaParams.push({
+                    ownerAddress: ataInitInstruction.params.ownerAddress,
+                    tokenName: ataInitInstruction.params.tokenName,
+                    ataAddress: ataInitInstruction.params.ataAddress,
+                    tokenAddress: ataInitInstruction.params.mintAddress,
+                    programId: ataInitInstruction.params.programId,
+                });
+            }
+        }
+    }
+    /**
+     *  Set a transfer
+     *
+     * @param {SendParams} params - params for the transfer
+     * @param {string} params.address - the receiver token address
+     * @param {string} params.amount - the amount sent
+     * @param {string} params.tokenName - name of token that is intended to send
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send({ address, amount, tokenName, tokenAddress, programId, decimalPlaces }) {
+        (0, utils_1.validateAddress)(address, 'address');
+        if (!amount || !(0, utils_1.isValidAmount)(amount)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing amount, got: ' + amount);
+        }
+        if (BigInt(amount) > UNSIGNED_BIGINT_MAX) {
+            throw new sdk_core_1.BuildTransactionError(`input amount ${amount} exceeds big int limit ${UNSIGNED_BIGINT_MAX}`);
+        }
+        this._sendParams.push({ address, amount, tokenName: tokenName, tokenAddress, programId, decimalPlaces });
+        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) {
+        (0, utils_1.validateOwnerAddress)(recipient.ownerAddress);
+        let tokenAddress;
+        if (recipient.tokenAddress) {
+            tokenAddress = recipient.tokenAddress;
+        }
+        else {
+            const token = (0, utils_1.getSolTokenFromTokenName)(recipient.tokenName);
+            if (token) {
+                tokenAddress = token.tokenAddress;
+            }
+            else {
+                throw new sdk_core_1.BuildTransactionError('Invalid token name, got: ' + recipient.tokenName);
+            }
+        }
+        (0, utils_1.validateMintAddress)(tokenAddress);
+        this._createAtaParams.push(recipient);
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        (0, assert_1.default)(this._sender, 'Sender must be set before building the transaction');
+        const sendInstructions = await Promise.all(this._sendParams.map(async (sendParams) => {
+            let tokenAddress;
+            let tokenName;
+            let programId;
+            let decimals;
+            if (sendParams.tokenAddress && sendParams.programId && sendParams.decimalPlaces != null) {
+                tokenAddress = sendParams.tokenAddress;
+                tokenName = sendParams.tokenName;
+                programId = sendParams.programId;
+                decimals = sendParams.decimalPlaces;
+            }
+            else {
+                const coin = (0, utils_1.getSolTokenFromTokenName)(sendParams.tokenName);
+                if (coin) {
+                    tokenAddress = coin.tokenAddress;
+                    tokenName = coin.name;
+                    programId = coin.programId;
+                    decimals = coin.decimalPlaces;
+                }
+                else {
+                    throw new Error(`Could not determine token information for ${sendParams.tokenName}`);
+                }
+            }
+            const sourceAddress = await (0, utils_1.getAssociatedTokenAccountAddress)(tokenAddress, this._sender, false, programId);
+            return {
+                type: constants_1.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 } : {}),
+                },
+            };
+        }));
+        const uniqueCreateAtaParams = lodash_1.default.uniqBy(this._createAtaParams, (recipient) => {
+            return recipient.ownerAddress + recipient.tokenName;
+        });
+        const createAtaInstructions = await Promise.all(uniqueCreateAtaParams.map(async (recipient) => {
+            let tokenAddress;
+            let tokenName;
+            let programId;
+            if (recipient.tokenAddress && recipient.programId) {
+                tokenName = recipient.tokenName;
+                tokenAddress = recipient.tokenAddress;
+                programId = recipient.programId;
+            }
+            else {
+                const coin = (0, utils_1.getSolTokenFromTokenName)(recipient.tokenName);
+                if (coin) {
+                    tokenName = coin.name;
+                    tokenAddress = coin.tokenAddress;
+                    programId = coin.programId;
+                }
+                else {
+                    throw new Error(`Could not determine token information for ${recipient.tokenName}`);
+                }
+            }
+            // Use the provided ataAddress if it exists, otherwise calculate it
+            let ataAddress = recipient.ataAddress;
+            if (!ataAddress) {
+                ataAddress = await (0, utils_1.getAssociatedTokenAccountAddress)(tokenAddress, recipient.ownerAddress, false, programId);
+            }
+            return {
+                type: constants_1.InstructionBuilderTypes.CreateAssociatedTokenAccount,
+                params: {
+                    ownerAddress: recipient.ownerAddress,
+                    mintAddress: tokenAddress,
+                    ataAddress,
+                    // Match transactionBuilder fee payer selection: when a distinct fee payer
+                    // is set (e.g. gas tank), it must fund ATA rent — not the token sender.
+                    payerAddress: this._feePayer ?? this._sender,
+                    tokenName: tokenName,
+                    programId: programId,
+                },
+            };
+        }));
+        const addPriorityFeeInstruction = {
+            type: constants_1.InstructionBuilderTypes.SetPriorityFee,
+            params: {
+                fee: this._priorityFee,
+            },
+        };
+        // 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: constants_1.InstructionBuilderTypes.PermissionlessThawIdempotent, params: this._permissionlessThaw }]
+            : [];
+        if (!this._priorityFee || this._priorityFee === Number(0)) {
+            this._instructionsData = [...createAtaInstructions, ...thawInstructions, ...sendInstructions];
+        }
+        else {
+            // order is important, createAtaInstructions must be before sendInstructions
+            this._instructionsData = [
+                addPriorityFeeInstruction,
+                ...createAtaInstructions,
+                ...thawInstructions,
+                ...sendInstructions,
+            ];
+        }
+        return await super.buildImplementation();
+    }
+}
+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 { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\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 { InstructionBuilderTypes } from './constants';\nimport {\n  AtaInit,\n  ExtraAccountMeta,\n  PermissionlessThawIdempotent,\n  TokenAssociateRecipient,\n  TokenTransfer,\n  SetPriorityFee,\n} from './iface';\nimport assert from 'assert';\nimport { TransactionBuilder } from './transactionBuilder';\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 TokenTransferBuilder extends TransactionBuilder {\n  private _sendParams: SendParams[] = [];\n  private _createAtaParams: TokenAssociateRecipient[];\n  private _transferHookAccounts?: ExtraAccountMeta[];\n  private _permissionlessThaw?: PermissionlessThawIdempotent['params'];\n\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 {TokenTransferBuilder} 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 {TokenTransferBuilder} 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.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          tokenAddress: transferInstruction.params.tokenAddress,\n          programId: transferInstruction.params.programId,\n          decimalPlaces: transferInstruction.params.decimalPlaces,\n        });\n      }\n      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          tokenAddress: ataInitInstruction.params.mintAddress,\n          programId: ataInitInstruction.params.programId,\n        });\n      }\n    }\n  }\n\n  /**\n   *  Set a transfer\n   *\n   * @param {SendParams} params - params for the transfer\n   * @param {string} params.address - the receiver token address\n   * @param {string} params.amount - the amount sent\n   * @param {string} params.tokenName - name of token that is intended to send\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  send({ address, amount, tokenName, tokenAddress, programId, decimalPlaces }: SendParams): this {\n    validateAddress(address, 'address');\n    if (!amount || !isValidAmount(amount)) {\n      throw new BuildTransactionError('Invalid or missing amount, got: ' + amount);\n    }\n    if (BigInt(amount) > UNSIGNED_BIGINT_MAX) {\n      throw new BuildTransactionError(`input amount ${amount} exceeds big int limit ${UNSIGNED_BIGINT_MAX}`);\n    }\n\n    this._sendParams.push({ address, amount, tokenName: tokenName, tokenAddress, programId, decimalPlaces });\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    let tokenAddress: string;\n    if (recipient.tokenAddress) {\n      tokenAddress = recipient.tokenAddress;\n    } else {\n      const token = getSolTokenFromTokenName(recipient.tokenName);\n      if (token) {\n        tokenAddress = token.tokenAddress;\n      } else {\n        throw new BuildTransactionError('Invalid token name, got: ' + recipient.tokenName);\n      }\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<TokenTransfer> => {\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          tokenAddress = sendParams.tokenAddress;\n          tokenName = sendParams.tokenName;\n          programId = sendParams.programId;\n          decimals = sendParams.decimalPlaces;\n        } else {\n          const coin = getSolTokenFromTokenName(sendParams.tokenName);\n          if (coin) {\n            tokenAddress = coin.tokenAddress;\n            tokenName = coin.name;\n            programId = coin.programId;\n            decimals = coin.decimalPlaces;\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      })\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        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 {\n          const coin = getSolTokenFromTokenName(recipient.tokenName);\n          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        }\n\n        // Use the provided ataAddress if it exists, otherwise calculate it\n        let ataAddress = recipient.ataAddress;\n        if (!ataAddress) {\n          ataAddress = await getAssociatedTokenAccountAddress(tokenAddress, recipient.ownerAddress, false, programId);\n        }\n        return {\n          type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n          params: {\n            ownerAddress: recipient.ownerAddress,\n            mintAddress: tokenAddress,\n            ataAddress,\n            // Match transactionBuilder fee payer selection: when a distinct fee payer\n            // is set (e.g. gas tank), it must fund ATA rent — not the token sender.\n            payerAddress: this._feePayer ?? this._sender,\n            tokenName: tokenName,\n            programId: programId,\n          },\n        };\n      })\n    );\n    const addPriorityFeeInstruction: SetPriorityFee = {\n      type: InstructionBuilderTypes.SetPriorityFee,\n      params: {\n        fee: this._priorityFee,\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    if (!this._priorityFee || this._priorityFee === Number(0)) {\n      this._instructionsData = [...createAtaInstructions, ...thawInstructions, ...sendInstructions];\n    } else {\n      // order is important, createAtaInstructions must be before sendInstructions\n      this._instructionsData = [\n        addPriorityFeeInstruction,\n        ...createAtaInstructions,\n        ...thawInstructions,\n        ...sendInstructions,\n      ];\n    }\n    return await super.buildImplementation();\n  }\n}\n"]}

package/dist/cjs/src/lib/transaction.d.ts.map

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