@bitgo-beta/sdk-coin-sol 7.6.4-beta.71 → 7.6.4-beta.710

package/dist/esm/lib/stakingWithdrawBuilder.js

@@ -0,0 +1,80 @@
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { InstructionBuilderTypes } from './constants';
+import assert from 'assert';
+import { isValidStakingAmount, validateAddress } from './utils';
+export class StakingWithdrawBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return TransactionType.StakingWithdraw;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.StakingWithdraw) {
+                const withdrawInstruction = instruction;
+                this.sender(withdrawInstruction.params.fromAddress);
+                this.stakingAddress(withdrawInstruction.params.stakingAddress);
+                this.amount(withdrawInstruction.params.amount);
+            }
+        }
+    }
+    /**
+     * The address of the staking account.
+     *
+     * @param {string} stakingAddress public address of the staking account
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    stakingAddress(stakingAddress) {
+        validateAddress(stakingAddress, 'stakingAddress');
+        this._stakingAddress = stakingAddress;
+        return this;
+    }
+    /**
+     * The amount to withdraw expressed in Lamports, 1 SOL = 1_000_000_000 lamports
+     *
+     * @param {string} amount expressed in Lamports
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    amount(amount) {
+        if (!isValidStakingAmount(amount)) {
+            throw new BuildTransactionError('Value cannot be zero or less');
+        }
+        this._amount = amount;
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._sender, 'Sender must be set before building the transaction');
+        assert(this._stakingAddress, 'Staking address must be set before building the transaction');
+        assert(this._amount, 'Amount must be set before building the transaction');
+        if (this._sender === this._stakingAddress) {
+            throw new BuildTransactionError('Sender address cannot be the same as the Staking address');
+        }
+        const stakingWithdrawData = {
+            type: InstructionBuilderTypes.StakingWithdraw,
+            params: {
+                fromAddress: this._sender,
+                stakingAddress: this._stakingAddress,
+                amount: this._amount,
+            },
+        };
+        this._instructionsData =
+            this._priorityFee && this._priorityFee !== Number(0)
+                ? [
+                    {
+                        type: InstructionBuilderTypes.SetPriorityFee,
+                        params: { fee: this._priorityFee },
+                    },
+                    stakingWithdrawData,
+                ]
+                : [stakingWithdrawData];
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,106 @@
+/**
+ * @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 { AccountInfo, Connection } from '@solana/web3.js';
+import { ExtraAccountMeta } from './iface';
+/**
+ * A minimal account-fetcher: given a base58 address, return its on-chain
+ * {@link AccountInfo} (with `data` already decoded into a `Buffer`) or `null`
+ * when the account does not exist. Callers supply their own transport (SDK node
+ * request, wallet-platform IMS RPC, a full `Connection`, etc.).
+ */
+export type SolAccountFetcher = (address: string) => Promise<AccountInfo<Buffer> | null>;
+/**
+ * Result of resolving the sRFC-37 Token ACL permissionless thaw for a mint / token account.
+ *
+ * When `applicable` is false (the mint has no Token ACL MintConfig, or permissionless thaw is
+ * disabled) all other fields are omitted and the caller should not emit a thaw instruction.
+ * When `applicable` is true, the fields are ready to thread into the token-transfer builder via
+ * `permissionlessThaw(...)`.
+ */
+export interface ResolvePermissionlessThawResult {
+    applicable: boolean;
+    gatingProgram?: string;
+    flagAccount?: string;
+    mintConfig?: string;
+    tokenProgram?: string;
+    systemProgram?: string;
+    extraAccounts?: ExtraAccountMeta[];
+}
+/**
+ * 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 declare function buildSolAccountConnection(fetch: SolAccountFetcher): Connection;
+/**
+ * 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 declare function resolveTransferHookAccounts(connection: Connection, params: {
+    mint: string;
+    source: string;
+    destination: string;
+    owner: string;
+    amount: string;
+}): Promise<ExtraAccountMeta[]>;
+/**
+ * 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 declare function resolvePermissionlessThaw(connection: Connection, params: {
+    mint: string;
+    tokenAccount: string;
+    tokenAccountOwner: string;
+    authority: string;
+}): Promise<ResolvePermissionlessThawResult>;
+//# sourceMappingURL=token2022Resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"token2022Resolve.d.ts","sourceRoot":"","sources":["../../../src/lib/token2022Resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAWH,OAAO,EACL,WAAW,EAGX,UAAU,EAIX,MAAM,iBAAiB,CAAC;AASzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;AAEzF;;;;;;;GAOG;AACH,MAAM,WAAW,+BAA+B;IAC9C,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,iBAAiB,GAAG,UAAU,CAQ9E;AA4DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,2BAA2B,CAC/C,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC3F,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8C7B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC3F,OAAO,CAAC,+BAA+B,CAAC,CAqE1C"}

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/tokenExtensions.d.ts

@@ -0,0 +1,26 @@
+import { SolTokenExtensions, SolTokenExtensionType } from '@bitgo-beta/statics';
+import { type Mint } from '@solana/spl-token';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+/**
+ * Result of reading a Token-2022 mint's extension data.
+ *
+ * `detectedTypeNames` lists EVERY extension present on the mint — including ones BitGo does
+ * not model — so callers can run the onboarding safety gate (`getUnsupportedSolTokenExtensions`).
+ * `extensions` is the typed, storable config for the extensions BitGo does model.
+ */
+export interface MintExtensionReadResult {
+    detectedTypeNames: string[];
+    extensions: SolTokenExtensions;
+}
+/** Human-readable names of every extension type present on the mint. */
+export declare function extensionTypeNames(mintInfo: Mint): string[];
+/** The subset of detected extensions that BitGo models. Pure — unit-testable without chain data. */
+export declare function mapModeledExtensions(detectedTypeNames: readonly string[]): SolTokenExtensionType[];
+/**
+ * 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.
+ */
+export declare function parseMintExtensions(mintInfo: Mint): MintExtensionReadResult;
+/** Fetch a Token-2022 mint and parse its extensions. Uses `finalized` commitment rules. */
+export declare function readMintExtensions(connection: Connection, mint: string | PublicKey, commitment?: Commitment): Promise<MintExtensionReadResult>;
+//# sourceMappingURL=tokenExtensions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenExtensions.d.ts","sourceRoot":"","sources":["../../../src/lib/tokenExtensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAUL,KAAK,IAAI,EAEV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,kBAAkB,CAAC;CAChC;AAYD,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,EAAE,CAK3D;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,GAAG,qBAAqB,EAAE,CASlG;AAcD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,IAAI,GAAG,uBAAuB,CAwD3E;AAED,2FAA2F;AAC3F,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,UAAU,GAAE,UAAwB,GACnC,OAAO,CAAC,uBAAuB,CAAC,CAIlC"}

package/dist/esm/lib/tokenExtensions.js

@@ -0,0 +1,99 @@
+import { SolTokenExtensionType } from '@bitgo-beta/statics';
+import { AccountState, ExtensionType, getExtensionData, getExtensionTypes, getInterestBearingMintConfigState, getMint, getPermanentDelegate, getTransferFeeConfig, getTransferHook, TOKEN_2022_PROGRAM_ID, } from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+/** Map from `@solana/spl-token` ExtensionType names to BitGo's modeled extension types. */
+const EXTENSION_NAME_MAP = {
+    TransferFeeConfig: SolTokenExtensionType.TransferFee,
+    TransferHook: SolTokenExtensionType.TransferHook,
+    PermanentDelegate: SolTokenExtensionType.PermanentDelegate,
+    InterestBearingConfig: SolTokenExtensionType.InterestBearing,
+    DefaultAccountState: SolTokenExtensionType.DefaultAccountState,
+    ScaledUiAmountConfig: SolTokenExtensionType.ScaledUiAmount,
+};
+/** Human-readable names of every extension type present on the mint. */
+export function extensionTypeNames(mintInfo) {
+    if (mintInfo.tlvData.length === 0) {
+        return [];
+    }
+    return getExtensionTypes(mintInfo.tlvData).map((t) => ExtensionType[t] ?? `unknown(${t})`);
+}
+/** The subset of detected extensions that BitGo models. Pure — unit-testable without chain data. */
+export 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;
+}
+// No SDK-level extension-combination assert: the on-chain program already
+// enforces its own invalid-combination rules at extension init
+// (`check_for_invalid_mint_extension_combinations` in token-2022), and it does
+// NOT forbid TransferHook + ConfidentialTransferMint. A previous assert here
+// rejected that legal pair and blocked onboarding of real mints. Custody
+// policy on which combinations BitGo will serve belongs to consumers
+// (statics `getUnsupportedSolTokenExtensions`, the AMS onboarding gate).
+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.
+ */
+export function parseMintExtensions(mintInfo) {
+    const detectedTypeNames = extensionTypeNames(mintInfo);
+    const extensions = { detected: mapModeledExtensions(detectedTypeNames) };
+    const authorities = {
+        mintAuthority: toBase58(mintInfo.mintAuthority),
+        freezeAuthority: toBase58(mintInfo.freezeAuthority),
+    };
+    const feeConfig = 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 = getTransferHook(mintInfo);
+    if (hook) {
+        extensions.transferHookProgramId = hook.programId.toBase58();
+    }
+    const delegate = getPermanentDelegate(mintInfo);
+    if (delegate?.delegate) {
+        authorities.permanentDelegate = delegate.delegate.toBase58();
+    }
+    const interest = 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 = getExtensionData(ExtensionType.DefaultAccountState, mintInfo.tlvData);
+    if (defaultStateData) {
+        extensions.defaultAccountState = {
+            frozen: defaultStateData[0] === 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. */
+export async function readMintExtensions(connection, mint, commitment = 'finalized') {
+    const mintPubkey = typeof mint === 'string' ? new PublicKey(mint) : mint;
+    const mintInfo = await getMint(connection, mintPubkey, commitment, 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\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// No SDK-level extension-combination assert: the on-chain program already\n// enforces its own invalid-combination rules at extension init\n// (`check_for_invalid_mint_extension_combinations` in token-2022), and it does\n// NOT forbid TransferHook + ConfidentialTransferMint. A previous assert here\n// rejected that legal pair and blocked onboarding of real mints. Custody\n// policy on which combinations BitGo will serve belongs to consumers\n// (statics `getUnsupportedSolTokenExtensions`, the AMS onboarding gate).\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\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"]}