@bitgo-beta/sdk-coin-sol 7.6.4-beta.613 → 7.6.4-beta.615

package/dist/esm/lib/token2022Resolve.js

@@ -0,0 +1,194 @@
+/**
+ * @prettier
+ *
+ * Reusable Token-2022 resolution logic (Transfer Hook extra accounts and sRFC-37
+ * Token ACL permissionless thaw), decoupled from the `Sol` coin class so any caller
+ * with its own account-fetcher (e.g. wallet-platform reading chain state via IMS RPC)
+ * can resolve these dependencies offline of the SDK's node transport.
+ *
+ * The resolution functions take a `Connection` (only `getAccountInfo` is required);
+ * {@link buildSolAccountConnection} adapts a plain {@link SolAccountFetcher} into the
+ * shape `@solana/spl-token`'s transfer-hook helpers expect.
+ */
+import { TOKEN_2022_PROGRAM_ID, addExtraAccountMetasForExecute, createTransferCheckedInstruction, getExtraAccountMetas, getTransferHook, resolveExtraAccountMeta, unpackMint, } from '@solana/spl-token';
+import { PublicKey as SolPublicKey, SystemProgram, } from '@solana/web3.js';
+import { THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR, TOKEN_ACL_FLAG_ACCOUNT_SEED, TOKEN_ACL_MINT_CONFIG_SEED, TOKEN_ACL_PROGRAM_ID, TOKEN_ACL_THAW_EXTRA_METAS_SEED, } from './constants';
+/**
+ * Build a minimal `Connection`-like shim backed by a {@link SolAccountFetcher}.
+ *
+ * `@solana/spl-token`'s transfer-hook resolution helpers only require
+ * `getAccountInfo(publicKey)` returning an `AccountInfo<Buffer>`. This adapts a
+ * plain address-based fetcher to that shape so any transport can drive the
+ * resolution below without opening a dedicated RPC connection.
+ *
+ * @param {SolAccountFetcher} fetch - fetcher returning decoded account info by address
+ * @returns {Connection} a shim exposing `getAccountInfo`, cast to `Connection`
+ */
+export function buildSolAccountConnection(fetch) {
+    const getAccountInfo = async (publicKey, _commitmentOrConfig) => {
+        return fetch(publicKey.toBase58());
+    };
+    return { getAccountInfo };
+}
+/**
+ * Map the extra keys appended to a resolved transfer instruction into the
+ * serializable {@link ExtraAccountMeta} shape.
+ */
+function toExtraAccountMetas(instruction, baseKeyCount) {
+    return instruction.keys.slice(baseKeyCount).map((meta) => ({
+        pubkey: meta.pubkey.toBase58(),
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable,
+    }));
+}
+/**
+ * Decode the fields of a Token ACL MintConfig account we depend on.
+ *
+ * Layout: `u8 discriminator, u8 bump, bool enablePermissionlessThaw, bool enablePermissionlessFreeze,
+ * pubkey mint(32), pubkey freezeAuthority(32), pubkey gatingProgram(32)`.
+ */
+function decodeTokenAclMintConfig(data) {
+    const enablePermissionlessThaw = data[2] === 1;
+    const gatingProgram = new SolPublicKey(data.subarray(68, 100));
+    return { enablePermissionlessThaw, gatingProgram };
+}
+/**
+ * Resolve the gating program's thaw ExtraAccountMetaList onto a can-thaw context.
+ *
+ * Mirrors the reference `resolveExtraMetas`: fetch the extra-metas account, unpack its
+ * ExtraAccountMeta entries, then resolve each one (fixed address, PDA, or account-data derived)
+ * against the accumulating metas using the spl-token transfer-hook helpers. When the extra-metas
+ * account does not exist, there are no extras to append.
+ */
+async function resolveTokenAclExtraMetas(connection, extraMetasAddress, previousMetas, gatingProgram) {
+    const instructionData = Buffer.from([THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR]);
+    const resolvedMetas = [...previousMetas];
+    const extraMetasAccount = await connection.getAccountInfo(extraMetasAddress);
+    if (!extraMetasAccount) {
+        return resolvedMetas;
+    }
+    const extraAccountMetas = getExtraAccountMetas(extraMetasAccount);
+    for (const extraAccountMeta of extraAccountMetas) {
+        const resolvedMeta = await resolveExtraAccountMeta(connection, extraAccountMeta, resolvedMetas, instructionData, gatingProgram);
+        resolvedMetas.push(resolvedMeta);
+    }
+    return resolvedMetas;
+}
+/**
+ * Resolve the Token-2022 Transfer Hook extra accounts for a specific transfer.
+ *
+ * This is generic: it works for any Token-2022 mint by reading the mint's
+ * TransferHook extension and the hook program's ExtraAccountMetaList live from
+ * the node, then resolving each extra account (including seed-derived PDAs) via
+ * the standard `spl-transfer-hook-interface` helpers. The returned metas are in
+ * the exact order the hook requires and are suitable for
+ * `TokenTransfer.params.transferHookAccounts`.
+ *
+ * When the mint has no Transfer Hook, this returns an empty array and callers can
+ * omit the param.
+ *
+ * @param {Connection} connection - a `Connection` (or shim) exposing `getAccountInfo`
+ * @param params - the transfer parameters
+ * @param {string} params.mint - the Token-2022 mint address
+ * @param {string} params.source - the source token account (sender ATA)
+ * @param {string} params.destination - the destination token account (recipient ATA)
+ * @param {string} params.owner - the source account owner / transfer authority
+ * @param {string} params.amount - the raw transfer amount in base units
+ * @returns {Promise<ExtraAccountMeta[]>} ordered extra account metas, or [] when no hook
+ */
+export async function resolveTransferHookAccounts(connection, params) {
+    const { mint, source, destination, owner, amount } = params;
+    const mintPubkey = new SolPublicKey(mint);
+    // Read the mint and detect whether a Transfer Hook extension is configured.
+    const mintAccountInfo = await connection.getAccountInfo(mintPubkey);
+    if (!mintAccountInfo) {
+        return [];
+    }
+    const mintState = unpackMint(mintPubkey, mintAccountInfo, TOKEN_2022_PROGRAM_ID);
+    const transferHook = getTransferHook(mintState);
+    if (!transferHook || transferHook.programId.equals(SolPublicKey.default)) {
+        return [];
+    }
+    const sourcePubkey = new SolPublicKey(source);
+    const destinationPubkey = new SolPublicKey(destination);
+    const ownerPubkey = new SolPublicKey(owner);
+    const transferAmount = BigInt(amount);
+    // Start from a base transferChecked instruction; addExtraAccountMetasForExecute
+    // appends the resolved extra accounts, the hook program, and the validation
+    // state account in the required order.
+    const instruction = createTransferCheckedInstruction(sourcePubkey, mintPubkey, destinationPubkey, ownerPubkey, transferAmount, mintState.decimals, [], TOKEN_2022_PROGRAM_ID);
+    const baseKeyCount = instruction.keys.length;
+    await addExtraAccountMetasForExecute(connection, instruction, transferHook.programId, sourcePubkey, mintPubkey, destinationPubkey, ownerPubkey, transferAmount);
+    return toExtraAccountMetas(instruction, baseKeyCount);
+}
+/**
+ * Resolve the sRFC-37 Token ACL permissionless-thaw dependencies for a token account.
+ *
+ * This is generic: it works for ANY allowlist/blocklist (DefaultAccountState) Token-2022 mint
+ * gated by the Token ACL program — no issuer is hardcoded. It reads the mint's MintConfig PDA
+ * live from the node, and only when permissionless thaw is enabled does it derive the flag /
+ * mint-config / thaw-extra-metas PDAs and resolve the gating program's extra account metas (in
+ * the exact order the gating program requires, mirroring `resolveExtraMetas`).
+ *
+ * When the mint is not a Token ACL mint, or permissionless thaw is disabled, this returns
+ * `{ applicable: false }` and callers skip the thaw.
+ *
+ * @param {Connection} connection - a `Connection` (or shim) exposing `getAccountInfo`
+ * @param params - the thaw parameters
+ * @param {string} params.mint - the Token-2022 mint address
+ * @param {string} params.tokenAccount - the token account (ATA) to thaw
+ * @param {string} params.tokenAccountOwner - the owner of the token account
+ * @param {string} params.authority - the signer invoking the thaw (fee payer / authority)
+ * @returns {Promise<ResolvePermissionlessThawResult>} the resolved thaw params, or `{ applicable: false }`
+ */
+export async function resolvePermissionlessThaw(connection, params) {
+    const { mint, tokenAccount, tokenAccountOwner, authority } = params;
+    const mintPubkey = new SolPublicKey(mint);
+    const tokenAccountPubkey = new SolPublicKey(tokenAccount);
+    const tokenAccountOwnerPubkey = new SolPublicKey(tokenAccountOwner);
+    const authorityPubkey = new SolPublicKey(authority);
+    const tokenAclProgramId = new SolPublicKey(TOKEN_ACL_PROGRAM_ID);
+    // 1. Read the mint's MintConfig PDA. Absent => the mint is not a Token ACL mint.
+    const [mintConfigPda] = SolPublicKey.findProgramAddressSync([Buffer.from(TOKEN_ACL_MINT_CONFIG_SEED), mintPubkey.toBuffer()], tokenAclProgramId);
+    const mintConfigAccount = await connection.getAccountInfo(mintConfigPda);
+    if (!mintConfigAccount) {
+        return { applicable: false };
+    }
+    // 2. Decode the MintConfig; permissionless thaw must be enabled.
+    const mintConfig = decodeTokenAclMintConfig(mintConfigAccount.data);
+    if (!mintConfig.enablePermissionlessThaw) {
+        return { applicable: false };
+    }
+    const gatingProgramPubkey = mintConfig.gatingProgram;
+    // 3. Derive the remaining PDAs (flag account under Token ACL, thaw extra metas under gating).
+    const [flagAccountPda] = SolPublicKey.findProgramAddressSync([Buffer.from(TOKEN_ACL_FLAG_ACCOUNT_SEED), tokenAccountPubkey.toBuffer()], tokenAclProgramId);
+    const [thawExtraMetasPda] = SolPublicKey.findProgramAddressSync([Buffer.from(TOKEN_ACL_THAW_EXTRA_METAS_SEED), mintPubkey.toBuffer()], gatingProgramPubkey);
+    // 4. Build the 6-account can-thaw context (all readonly), then resolve the gating program's
+    //    extra account metas onto it.
+    const canThawContext = [
+        { pubkey: authorityPubkey, isSigner: false, isWritable: false },
+        { pubkey: tokenAccountPubkey, isSigner: false, isWritable: false },
+        { pubkey: mintPubkey, isSigner: false, isWritable: false },
+        { pubkey: tokenAccountOwnerPubkey, isSigner: false, isWritable: false },
+        { pubkey: flagAccountPda, isSigner: false, isWritable: false },
+        { pubkey: thawExtraMetasPda, isSigner: false, isWritable: false },
+    ];
+    const resolvedMetas = await resolveTokenAclExtraMetas(connection, thawExtraMetasPda, canThawContext, gatingProgramPubkey);
+    // 5. Drop the first five context accounts; the remainder ([thawExtraMetas, ...extras]) are the
+    //    accounts appended after the thaw instruction's fixed nine.
+    const extraAccounts = resolvedMetas.slice(5).map((meta) => ({
+        pubkey: meta.pubkey.toBase58(),
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable,
+    }));
+    return {
+        applicable: true,
+        gatingProgram: gatingProgramPubkey.toBase58(),
+        flagAccount: flagAccountPda.toBase58(),
+        mintConfig: mintConfigPda.toBase58(),
+        tokenProgram: TOKEN_2022_PROGRAM_ID.toBase58(),
+        systemProgram: SystemProgram.programId.toBase58(),
+        extraAccounts,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token2022Resolve.js","sourceRoot":"","sources":["../../../src/lib/token2022Resolve.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * Reusable Token-2022 resolution logic (Transfer Hook extra accounts and sRFC-37\n * Token ACL permissionless thaw), decoupled from the `Sol` coin class so any caller\n * with its own account-fetcher (e.g. wallet-platform reading chain state via IMS RPC)\n * can resolve these dependencies offline of the SDK's node transport.\n *\n * The resolution functions take a `Connection` (only `getAccountInfo` is required);\n * {@link buildSolAccountConnection} adapts a plain {@link SolAccountFetcher} into the\n * shape `@solana/spl-token`'s transfer-hook helpers expect.\n */\n\nimport {\n  TOKEN_2022_PROGRAM_ID,\n  addExtraAccountMetasForExecute,\n  createTransferCheckedInstruction,\n  getExtraAccountMetas,\n  getTransferHook,\n  resolveExtraAccountMeta,\n  unpackMint,\n} from '@solana/spl-token';\nimport {\n  AccountInfo,\n  AccountMeta,\n  Commitment,\n  Connection,\n  PublicKey as SolPublicKey,\n  SystemProgram,\n  TransactionInstruction,\n} from '@solana/web3.js';\n\nimport {\n  THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR,\n  TOKEN_ACL_FLAG_ACCOUNT_SEED,\n  TOKEN_ACL_MINT_CONFIG_SEED,\n  TOKEN_ACL_PROGRAM_ID,\n  TOKEN_ACL_THAW_EXTRA_METAS_SEED,\n} from './constants';\nimport { ExtraAccountMeta } from './iface';\n\n/**\n * A minimal account-fetcher: given a base58 address, return its on-chain\n * {@link AccountInfo} (with `data` already decoded into a `Buffer`) or `null`\n * when the account does not exist. Callers supply their own transport (SDK node\n * request, wallet-platform IMS RPC, a full `Connection`, etc.).\n */\nexport type SolAccountFetcher = (address: string) => Promise<AccountInfo<Buffer> | null>;\n\n/**\n * Result of resolving the sRFC-37 Token ACL permissionless thaw for a mint / token account.\n *\n * When `applicable` is false (the mint has no Token ACL MintConfig, or permissionless thaw is\n * disabled) all other fields are omitted and the caller should not emit a thaw instruction.\n * When `applicable` is true, the fields are ready to thread into the token-transfer builder via\n * `permissionlessThaw(...)`.\n */\nexport interface ResolvePermissionlessThawResult {\n  applicable: boolean;\n  gatingProgram?: string;\n  flagAccount?: string;\n  mintConfig?: string;\n  tokenProgram?: string;\n  systemProgram?: string;\n  extraAccounts?: ExtraAccountMeta[];\n}\n\n/**\n * Build a minimal `Connection`-like shim backed by a {@link SolAccountFetcher}.\n *\n * `@solana/spl-token`'s transfer-hook resolution helpers only require\n * `getAccountInfo(publicKey)` returning an `AccountInfo<Buffer>`. This adapts a\n * plain address-based fetcher to that shape so any transport can drive the\n * resolution below without opening a dedicated RPC connection.\n *\n * @param {SolAccountFetcher} fetch - fetcher returning decoded account info by address\n * @returns {Connection} a shim exposing `getAccountInfo`, cast to `Connection`\n */\nexport function buildSolAccountConnection(fetch: SolAccountFetcher): Connection {\n  const getAccountInfo = async (\n    publicKey: SolPublicKey,\n    _commitmentOrConfig?: Commitment\n  ): Promise<AccountInfo<Buffer> | null> => {\n    return fetch(publicKey.toBase58());\n  };\n  return { getAccountInfo } as unknown as Connection;\n}\n\n/**\n * Map the extra keys appended to a resolved transfer instruction into the\n * serializable {@link ExtraAccountMeta} shape.\n */\nfunction toExtraAccountMetas(instruction: TransactionInstruction, baseKeyCount: number): ExtraAccountMeta[] {\n  return instruction.keys.slice(baseKeyCount).map((meta) => ({\n    pubkey: meta.pubkey.toBase58(),\n    isSigner: meta.isSigner,\n    isWritable: meta.isWritable,\n  }));\n}\n\n/**\n * Decode the fields of a Token ACL MintConfig account we depend on.\n *\n * Layout: `u8 discriminator, u8 bump, bool enablePermissionlessThaw, bool enablePermissionlessFreeze,\n * pubkey mint(32), pubkey freezeAuthority(32), pubkey gatingProgram(32)`.\n */\nfunction decodeTokenAclMintConfig(data: Buffer): { enablePermissionlessThaw: boolean; gatingProgram: SolPublicKey } {\n  const enablePermissionlessThaw = data[2] === 1;\n  const gatingProgram = new SolPublicKey(data.subarray(68, 100));\n  return { enablePermissionlessThaw, gatingProgram };\n}\n\n/**\n * Resolve the gating program's thaw ExtraAccountMetaList onto a can-thaw context.\n *\n * Mirrors the reference `resolveExtraMetas`: fetch the extra-metas account, unpack its\n * ExtraAccountMeta entries, then resolve each one (fixed address, PDA, or account-data derived)\n * against the accumulating metas using the spl-token transfer-hook helpers. When the extra-metas\n * account does not exist, there are no extras to append.\n */\nasync function resolveTokenAclExtraMetas(\n  connection: Connection,\n  extraMetasAddress: SolPublicKey,\n  previousMetas: AccountMeta[],\n  gatingProgram: SolPublicKey\n): Promise<AccountMeta[]> {\n  const instructionData = Buffer.from([THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR]);\n  const resolvedMetas: AccountMeta[] = [...previousMetas];\n  const extraMetasAccount = await connection.getAccountInfo(extraMetasAddress);\n  if (!extraMetasAccount) {\n    return resolvedMetas;\n  }\n  const extraAccountMetas = getExtraAccountMetas(extraMetasAccount);\n  for (const extraAccountMeta of extraAccountMetas) {\n    const resolvedMeta = await resolveExtraAccountMeta(\n      connection,\n      extraAccountMeta,\n      resolvedMetas,\n      instructionData,\n      gatingProgram\n    );\n    resolvedMetas.push(resolvedMeta);\n  }\n  return resolvedMetas;\n}\n\n/**\n * Resolve the Token-2022 Transfer Hook extra accounts for a specific transfer.\n *\n * This is generic: it works for any Token-2022 mint by reading the mint's\n * TransferHook extension and the hook program's ExtraAccountMetaList live from\n * the node, then resolving each extra account (including seed-derived PDAs) via\n * the standard `spl-transfer-hook-interface` helpers. The returned metas are in\n * the exact order the hook requires and are suitable for\n * `TokenTransfer.params.transferHookAccounts`.\n *\n * When the mint has no Transfer Hook, this returns an empty array and callers can\n * omit the param.\n *\n * @param {Connection} connection - a `Connection` (or shim) exposing `getAccountInfo`\n * @param params - the transfer parameters\n * @param {string} params.mint - the Token-2022 mint address\n * @param {string} params.source - the source token account (sender ATA)\n * @param {string} params.destination - the destination token account (recipient ATA)\n * @param {string} params.owner - the source account owner / transfer authority\n * @param {string} params.amount - the raw transfer amount in base units\n * @returns {Promise<ExtraAccountMeta[]>} ordered extra account metas, or [] when no hook\n */\nexport async function resolveTransferHookAccounts(\n  connection: Connection,\n  params: { mint: string; source: string; destination: string; owner: string; amount: string }\n): Promise<ExtraAccountMeta[]> {\n  const { mint, source, destination, owner, amount } = params;\n  const mintPubkey = new SolPublicKey(mint);\n\n  // Read the mint and detect whether a Transfer Hook extension is configured.\n  const mintAccountInfo = await connection.getAccountInfo(mintPubkey);\n  if (!mintAccountInfo) {\n    return [];\n  }\n  const mintState = unpackMint(mintPubkey, mintAccountInfo, TOKEN_2022_PROGRAM_ID);\n  const transferHook = getTransferHook(mintState);\n  if (!transferHook || transferHook.programId.equals(SolPublicKey.default)) {\n    return [];\n  }\n\n  const sourcePubkey = new SolPublicKey(source);\n  const destinationPubkey = new SolPublicKey(destination);\n  const ownerPubkey = new SolPublicKey(owner);\n  const transferAmount = BigInt(amount);\n\n  // Start from a base transferChecked instruction; addExtraAccountMetasForExecute\n  // appends the resolved extra accounts, the hook program, and the validation\n  // state account in the required order.\n  const instruction = createTransferCheckedInstruction(\n    sourcePubkey,\n    mintPubkey,\n    destinationPubkey,\n    ownerPubkey,\n    transferAmount,\n    mintState.decimals,\n    [],\n    TOKEN_2022_PROGRAM_ID\n  );\n  const baseKeyCount = instruction.keys.length;\n  await addExtraAccountMetasForExecute(\n    connection,\n    instruction,\n    transferHook.programId,\n    sourcePubkey,\n    mintPubkey,\n    destinationPubkey,\n    ownerPubkey,\n    transferAmount\n  );\n\n  return toExtraAccountMetas(instruction, baseKeyCount);\n}\n\n/**\n * Resolve the sRFC-37 Token ACL permissionless-thaw dependencies for a token account.\n *\n * This is generic: it works for ANY allowlist/blocklist (DefaultAccountState) Token-2022 mint\n * gated by the Token ACL program — no issuer is hardcoded. It reads the mint's MintConfig PDA\n * live from the node, and only when permissionless thaw is enabled does it derive the flag /\n * mint-config / thaw-extra-metas PDAs and resolve the gating program's extra account metas (in\n * the exact order the gating program requires, mirroring `resolveExtraMetas`).\n *\n * When the mint is not a Token ACL mint, or permissionless thaw is disabled, this returns\n * `{ applicable: false }` and callers skip the thaw.\n *\n * @param {Connection} connection - a `Connection` (or shim) exposing `getAccountInfo`\n * @param params - the thaw parameters\n * @param {string} params.mint - the Token-2022 mint address\n * @param {string} params.tokenAccount - the token account (ATA) to thaw\n * @param {string} params.tokenAccountOwner - the owner of the token account\n * @param {string} params.authority - the signer invoking the thaw (fee payer / authority)\n * @returns {Promise<ResolvePermissionlessThawResult>} the resolved thaw params, or `{ applicable: false }`\n */\nexport async function resolvePermissionlessThaw(\n  connection: Connection,\n  params: { mint: string; tokenAccount: string; tokenAccountOwner: string; authority: string }\n): Promise<ResolvePermissionlessThawResult> {\n  const { mint, tokenAccount, tokenAccountOwner, authority } = params;\n  const mintPubkey = new SolPublicKey(mint);\n  const tokenAccountPubkey = new SolPublicKey(tokenAccount);\n  const tokenAccountOwnerPubkey = new SolPublicKey(tokenAccountOwner);\n  const authorityPubkey = new SolPublicKey(authority);\n  const tokenAclProgramId = new SolPublicKey(TOKEN_ACL_PROGRAM_ID);\n\n  // 1. Read the mint's MintConfig PDA. Absent => the mint is not a Token ACL mint.\n  const [mintConfigPda] = SolPublicKey.findProgramAddressSync(\n    [Buffer.from(TOKEN_ACL_MINT_CONFIG_SEED), mintPubkey.toBuffer()],\n    tokenAclProgramId\n  );\n  const mintConfigAccount = await connection.getAccountInfo(mintConfigPda);\n  if (!mintConfigAccount) {\n    return { applicable: false };\n  }\n\n  // 2. Decode the MintConfig; permissionless thaw must be enabled.\n  const mintConfig = decodeTokenAclMintConfig(mintConfigAccount.data);\n  if (!mintConfig.enablePermissionlessThaw) {\n    return { applicable: false };\n  }\n  const gatingProgramPubkey = mintConfig.gatingProgram;\n\n  // 3. Derive the remaining PDAs (flag account under Token ACL, thaw extra metas under gating).\n  const [flagAccountPda] = SolPublicKey.findProgramAddressSync(\n    [Buffer.from(TOKEN_ACL_FLAG_ACCOUNT_SEED), tokenAccountPubkey.toBuffer()],\n    tokenAclProgramId\n  );\n  const [thawExtraMetasPda] = SolPublicKey.findProgramAddressSync(\n    [Buffer.from(TOKEN_ACL_THAW_EXTRA_METAS_SEED), mintPubkey.toBuffer()],\n    gatingProgramPubkey\n  );\n\n  // 4. Build the 6-account can-thaw context (all readonly), then resolve the gating program's\n  //    extra account metas onto it.\n  const canThawContext: AccountMeta[] = [\n    { pubkey: authorityPubkey, isSigner: false, isWritable: false },\n    { pubkey: tokenAccountPubkey, isSigner: false, isWritable: false },\n    { pubkey: mintPubkey, isSigner: false, isWritable: false },\n    { pubkey: tokenAccountOwnerPubkey, isSigner: false, isWritable: false },\n    { pubkey: flagAccountPda, isSigner: false, isWritable: false },\n    { pubkey: thawExtraMetasPda, isSigner: false, isWritable: false },\n  ];\n  const resolvedMetas = await resolveTokenAclExtraMetas(\n    connection,\n    thawExtraMetasPda,\n    canThawContext,\n    gatingProgramPubkey\n  );\n\n  // 5. Drop the first five context accounts; the remainder ([thawExtraMetas, ...extras]) are the\n  //    accounts appended after the thaw instruction's fixed nine.\n  const extraAccounts = resolvedMetas.slice(5).map((meta) => ({\n    pubkey: meta.pubkey.toBase58(),\n    isSigner: meta.isSigner,\n    isWritable: meta.isWritable,\n  }));\n\n  return {\n    applicable: true,\n    gatingProgram: gatingProgramPubkey.toBase58(),\n    flagAccount: flagAccountPda.toBase58(),\n    mintConfig: mintConfigPda.toBase58(),\n    tokenProgram: TOKEN_2022_PROGRAM_ID.toBase58(),\n    systemProgram: SystemProgram.programId.toBase58(),\n    extraAccounts,\n  };\n}\n"]}

package/dist/esm/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/esm/lib/tokenTransferBuilder.d.ts.map

@@ -1 +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,EAAW,uBAAuB,EAAiC,MAAM,SAAS,CAAC;AAE1F,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;gBAExC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,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;CAkG5D"}
+{"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/esm/lib/tokenTransferBuilder.js

@@ -11,6 +11,36 @@ export class TokenTransferBuilder extends TransactionBuilder {
         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 TransactionType.Send;
     }
@@ -125,6 +155,7 @@ export class TokenTransferBuilder extends TransactionBuilder {
                     tokenAddress: tokenAddress,
                     programId: programId,
                     decimalPlaces: decimals,
+                    ...(this._transferHookAccounts ? { transferHookAccounts: this._transferHookAccounts } : {}),
                 },
             };
         }));
@@ -176,14 +207,24 @@ export class TokenTransferBuilder extends TransactionBuilder {
                 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: InstructionBuilderTypes.PermissionlessThawIdempotent, params: this._permissionlessThaw }]
+            : [];
         if (!this._priorityFee || this._priorityFee === Number(0)) {
-            this._instructionsData = [...createAtaInstructions, ...sendInstructions];
+            this._instructionsData = [...createAtaInstructions, ...thawInstructions, ...sendInstructions];
         }
         else {
             // order is important, createAtaInstructions must be before sendInstructions
-            this._instructionsData = [addPriorityFeeInstruction, ...createAtaInstructions, ...sendInstructions];
+            this._instructionsData = [
+                addPriorityFeeInstruction,
+                ...createAtaInstructions,
+                ...thawInstructions,
+                ...sendInstructions,
+            ];
         }
         return await super.buildImplementation();
     }
 }
-//# 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 { AtaInit, TokenAssociateRecipient, TokenTransfer, SetPriorityFee } 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\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._createAtaParams = [];\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          },\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    if (!this._priorityFee || this._priorityFee === Number(0)) {\n      this._instructionsData = [...createAtaInstructions, ...sendInstructions];\n    } else {\n      // order is important, createAtaInstructions must be before sendInstructions\n      this._instructionsData = [addPriorityFeeInstruction, ...createAtaInstructions, ...sendInstructions];\n    }\n    return await super.buildImplementation();\n  }\n}\n"]}
+//# 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/esm/lib/transferBuilderV2.d.ts

@@ -2,7 +2,7 @@ import { TransactionBuilder } from './transactionBuilder';
 import { TransactionType } from '@bitgo-beta/sdk-core';
 import { Transaction } from './transaction';
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-import { TokenAssociateRecipient } from './iface';
+import { ExtraAccountMeta, PermissionlessThawIdempotent, TokenAssociateRecipient } from './iface';
 export interface SendParams {
     address: string;
     amount: string;
@@ -14,7 +14,33 @@ export interface SendParams {
 export declare class TransferBuilderV2 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 {TransferBuilderV2} 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 {TransferBuilderV2} This transaction builder
+     */
+    transferHookAccounts(metas: ExtraAccountMeta[]): this;
     protected get transactionType(): TransactionType;
     initBuilder(tx: Transaction): void;
     /**

package/dist/esm/lib/transferBuilderV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transferBuilderV2.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilderV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAS5C,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAW,uBAAuB,EAA2C,MAAM,SAAS,CAAC;AAIpG,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID,qBAAa,iBAAkB,SAAQ,kBAAkB;IACvD,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,gBAAgB,CAA4B;gBACxC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA8BlC;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAMpC;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAiBlC;;;;;;OAMG;IACH,4BAA4B,CAAC,SAAS,EAAE,uBAAuB,GAAG,IAAI;IAmBtE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAgH5D"}
+{"version":3,"file":"transferBuilderV2.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilderV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAS5C,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAEL,gBAAgB,EAChB,4BAA4B,EAC5B,uBAAuB,EAIxB,MAAM,SAAS,CAAC;AAIjB,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID,qBAAa,iBAAkB,SAAQ,kBAAkB;IACvD,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,qBAAqB,CAAC,CAAqB;IACnD,OAAO,CAAC,mBAAmB,CAAC,CAAyC;gBACzD,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;IA8BlC;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAMpC;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAiBlC;;;;;;OAMG;IACH,4BAA4B,CAAC,SAAS,EAAE,uBAAuB,GAAG,IAAI;IAmBtE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CA4H5D"}