@bitgo-beta/sdk-coin-sol 7.6.4-beta.66 → 7.6.4-beta.660

package/dist/esm/lib/constants.js

@@ -0,0 +1,264 @@
+export const MEMO_PROGRAM_PK = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
+export const SEED_LENGTH = 32;
+export const MAX_MEMO_LENGTH = 130;
+export const STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT = 2282880;
+export const UNAVAILABLE_TEXT = 'UNAVAILABLE';
+/**
+ * Sysvar instructions account address — used by Token-2022 confidential transfer
+ * instructions to locate inline proof verification instructions in the same transaction.
+ */
+export const INSTRUCTIONS_SYSVAR_ADDRESS = 'Sysvar1nstructions1111111111111111111111111';
+/**
+ * Canonical on-chain program id of the zk-elgamal-proof program.
+ *
+ * This is the same across mainnet, devnet, and testnet — it is a native
+ * built-in program. Callers can override via ConfidentialTransferBuilder
+ * .zkProofProgramId() if targeting a custom deployment.
+ *
+ * Note: The deprecated zk-token-proof program id is
+ * `ZkTokenProof1111111111111111111111111111111`.
+ */
+export const ZK_ELGAMAL_PROOF_PROGRAM_ID = 'ZkE1Gama1Proof11111111111111111111111111111';
+/**
+ * Token-2022 confidential transfer extension discriminator (byte 0 of instruction data).
+ */
+export const CT_EXT_DISCRIMINATOR = 27;
+/**
+ * Valid CT sub-instruction discriminators (byte 1 after CT_EXT_DISCRIMINATOR).
+ * Used for transaction type detection (getTransactionType / deriveTransactionType).
+ */
+export const CT_SUB_DISCRIMINATORS = new Set([
+    2, // ConfigureAccount
+    5, // Deposit
+    6, // Withdraw
+    7, // Transfer
+    8, // ApplyPendingBalance
+]);
+/**
+ * Maximum over-the-wire size of a Solana transaction (in bytes)
+ *
+ * Source: https://github.com/anza-xyz/agave/blob/v2.1.13/sdk/packet/src/lib.rs#L27-L29
+ *
+ * Calculation:
+ * - IPv6 minimum MTU: 1280 bytes
+ * - IPv6 header: 40 bytes
+ * - Fragment/UDP header: 8 bytes
+ * - Result: 1280 - 40 - 8 = 1232 bytes
+ *
+ * This limit is designed to avoid packet fragmentation on typical internet infrastructure.
+ * Transactions exceeding this limit will fail to serialize with a RangeError during
+ * the encoding of the transaction message.
+ *
+ * Reference: https://solana.com/docs/core/transactions#transaction-size
+ */
+export const SOLANA_TRANSACTION_MAX_SIZE = 1232;
+export const JITO_STAKE_POOL_ADDRESS = 'Jito4APyf642JPZPx3hGc6WWJ8zPKtRbRs4P815Awbb';
+export const JITOSOL_MINT_ADDRESS = 'J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn';
+export const JITO_STAKE_POOL_RESERVE_ACCOUNT = 'BgKUXdS29YcHCFrPm5M8oLHiTzZaMDjsebggjoaQ6KFL';
+export const JITO_STAKE_POOL_RESERVE_ACCOUNT_TESTNET = 'rrWBQqRqBXYZw3CmPCCcjFxQ2Ds4JFJd7oRQJ997dhz';
+export const JITO_MANAGER_FEE_ACCOUNT = 'feeeFLLsam6xZJFc6UQFrHqkvVt4jfmVvi2BRLkUZ4i';
+export const JITO_MANAGER_FEE_ACCOUNT_TESTNET = 'DH7tmjoQ5zjqcgfYJU22JqmXhP5EY1tkbYpgVWUS2oNo';
+/**
+ * On-chain program id of the sRFC-37 Token ACL program. This single program gates every
+ * allowlist/blocklist (DefaultAccountState) Token-2022 mint, so the value is generic and never
+ * tied to a specific issuer.
+ */
+export const TOKEN_ACL_PROGRAM_ID = 'TACLkU6CiCdkQN2MjoyDkVg2yAH9zkxiHDsiztQ52TP';
+/**
+ * Instruction discriminator (a single u8 byte) for the Token ACL `ThawPermissionlessIdempotent`
+ * instruction.
+ */
+export const THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR = 9;
+/** PDA seed prefix (under the Token ACL program) for a mint's MintConfig account. */
+export const TOKEN_ACL_MINT_CONFIG_SEED = 'MINT_CONFIG';
+/** PDA seed prefix (under the Token ACL program) for a token account's thaw flag account. */
+export const TOKEN_ACL_FLAG_ACCOUNT_SEED = 'FLAG_ACCOUNT';
+/** PDA seed prefix (under the gating program) for a mint's thaw ExtraAccountMetaList account. */
+export const TOKEN_ACL_THAW_EXTRA_METAS_SEED = 'thaw_extra_account_metas';
+// Sdk instructions, mainly to check decoded types.
+export var ValidInstructionTypesEnum;
+(function (ValidInstructionTypesEnum) {
+    ValidInstructionTypesEnum["AdvanceNonceAccount"] = "AdvanceNonceAccount";
+    ValidInstructionTypesEnum["Create"] = "Create";
+    ValidInstructionTypesEnum["InitializeNonceAccount"] = "InitializeNonceAccount";
+    ValidInstructionTypesEnum["StakingInitialize"] = "Initialize";
+    ValidInstructionTypesEnum["StakingDelegate"] = "Delegate";
+    ValidInstructionTypesEnum["StakingDeactivate"] = "Deactivate";
+    ValidInstructionTypesEnum["StakingWithdraw"] = "Withdraw";
+    ValidInstructionTypesEnum["Transfer"] = "Transfer";
+    ValidInstructionTypesEnum["TokenTransfer"] = "TokenTransfer";
+    ValidInstructionTypesEnum["Memo"] = "Memo";
+    ValidInstructionTypesEnum["InitializeAssociatedTokenAccount"] = "InitializeAssociatedTokenAccount";
+    ValidInstructionTypesEnum["CloseAssociatedTokenAccount"] = "CloseAssociatedTokenAccount";
+    ValidInstructionTypesEnum["RecoverNestedAssociatedTokenAccount"] = "RecoverNestedAssociatedTokenAccount";
+    ValidInstructionTypesEnum["Allocate"] = "Allocate";
+    ValidInstructionTypesEnum["Assign"] = "Assign";
+    ValidInstructionTypesEnum["Split"] = "Split";
+    ValidInstructionTypesEnum["Authorize"] = "Authorize";
+    ValidInstructionTypesEnum["SetComputeUnitLimit"] = "SetComputeUnitLimit";
+    ValidInstructionTypesEnum["SetPriorityFee"] = "SetPriorityFee";
+    ValidInstructionTypesEnum["MintTo"] = "MintTo";
+    ValidInstructionTypesEnum["Burn"] = "Burn";
+    ValidInstructionTypesEnum["DepositSol"] = "DepositSol";
+    ValidInstructionTypesEnum["WithdrawStake"] = "WithdrawStake";
+    ValidInstructionTypesEnum["Approve"] = "Approve";
+    ValidInstructionTypesEnum["CustomInstruction"] = "CustomInstruction";
+    ValidInstructionTypesEnum["PermissionlessThawIdempotent"] = "PermissionlessThawIdempotent";
+    // Confidential Transfer instruction types (Token-2022 CT extension + zk-elgamal-proof)
+    ValidInstructionTypesEnum["ConfigureConfidentialTransferAccount"] = "ConfigureConfidentialTransferAccount";
+    ValidInstructionTypesEnum["ApplyPendingBalance"] = "ApplyPendingBalance";
+    ValidInstructionTypesEnum["ConfidentialDeposit"] = "ConfidentialDeposit";
+    ValidInstructionTypesEnum["ConfidentialWithdraw"] = "ConfidentialWithdraw";
+    ValidInstructionTypesEnum["ConfidentialTransfer"] = "ConfidentialTransfer";
+    ValidInstructionTypesEnum["VerifyPubkeyValidity"] = "VerifyPubkeyValidity";
+    ValidInstructionTypesEnum["VerifyEqualityProof"] = "VerifyEqualityProof";
+    ValidInstructionTypesEnum["VerifyValidityProof"] = "VerifyValidityProof";
+    ValidInstructionTypesEnum["VerifyRangeProof"] = "VerifyRangeProof";
+})(ValidInstructionTypesEnum || (ValidInstructionTypesEnum = {}));
+// Internal instructions types
+export var InstructionBuilderTypes;
+(function (InstructionBuilderTypes) {
+    InstructionBuilderTypes["CreateNonceAccount"] = "CreateNonceAccount";
+    InstructionBuilderTypes["StakingActivate"] = "Activate";
+    InstructionBuilderTypes["StakingDeactivate"] = "Deactivate";
+    InstructionBuilderTypes["StakingWithdraw"] = "Withdraw";
+    InstructionBuilderTypes["Transfer"] = "Transfer";
+    InstructionBuilderTypes["Memo"] = "Memo";
+    InstructionBuilderTypes["NonceAdvance"] = "NonceAdvance";
+    InstructionBuilderTypes["CreateAssociatedTokenAccount"] = "CreateAssociatedTokenAccount";
+    InstructionBuilderTypes["CloseAssociatedTokenAccount"] = "CloseAssociatedTokenAccount";
+    InstructionBuilderTypes["RecoverNestedAssociatedTokenAccount"] = "RecoverNestedAssociatedTokenAccount";
+    InstructionBuilderTypes["TokenTransfer"] = "TokenTransfer";
+    InstructionBuilderTypes["StakingAuthorize"] = "Authorize";
+    InstructionBuilderTypes["StakingDelegate"] = "Delegate";
+    InstructionBuilderTypes["SetComputeUnitLimit"] = "SetComputeUnitLimit";
+    InstructionBuilderTypes["SetPriorityFee"] = "SetPriorityFee";
+    InstructionBuilderTypes["MintTo"] = "MintTo";
+    InstructionBuilderTypes["Burn"] = "Burn";
+    InstructionBuilderTypes["CustomInstruction"] = "CustomInstruction";
+    InstructionBuilderTypes["VersionedCustomInstruction"] = "VersionedCustomInstruction";
+    InstructionBuilderTypes["Approve"] = "Approve";
+    InstructionBuilderTypes["WithdrawStake"] = "WithdrawStake";
+    InstructionBuilderTypes["PermissionlessThawIdempotent"] = "PermissionlessThawIdempotent";
+    // Confidential Transfer instruction types (Token-2022 CT extension + zk-elgamal-proof)
+    InstructionBuilderTypes["ConfigureConfidentialTransferAccount"] = "ConfigureConfidentialTransferAccount";
+    InstructionBuilderTypes["ApplyPendingBalance"] = "ApplyPendingBalance";
+    InstructionBuilderTypes["ConfidentialDeposit"] = "ConfidentialDeposit";
+    InstructionBuilderTypes["ConfidentialWithdraw"] = "ConfidentialWithdraw";
+    InstructionBuilderTypes["ConfidentialTransfer"] = "ConfidentialTransfer";
+    InstructionBuilderTypes["VerifyPubkeyValidity"] = "VerifyPubkeyValidity";
+    InstructionBuilderTypes["VerifyEqualityProof"] = "VerifyEqualityProof";
+    InstructionBuilderTypes["VerifyValidityProof"] = "VerifyValidityProof";
+    InstructionBuilderTypes["VerifyRangeProof"] = "VerifyRangeProof";
+})(InstructionBuilderTypes || (InstructionBuilderTypes = {}));
+export const VALID_SYSTEM_INSTRUCTION_TYPES = [
+    ValidInstructionTypesEnum.AdvanceNonceAccount,
+    ValidInstructionTypesEnum.Create,
+    ValidInstructionTypesEnum.StakingInitialize,
+    ValidInstructionTypesEnum.StakingDelegate,
+    ValidInstructionTypesEnum.StakingDeactivate,
+    ValidInstructionTypesEnum.StakingWithdraw,
+    ValidInstructionTypesEnum.Transfer,
+    ValidInstructionTypesEnum.InitializeNonceAccount,
+    ValidInstructionTypesEnum.Memo,
+    ValidInstructionTypesEnum.InitializeAssociatedTokenAccount,
+    ValidInstructionTypesEnum.CloseAssociatedTokenAccount,
+    ValidInstructionTypesEnum.RecoverNestedAssociatedTokenAccount,
+    ValidInstructionTypesEnum.TokenTransfer,
+    ValidInstructionTypesEnum.Allocate,
+    ValidInstructionTypesEnum.Assign,
+    ValidInstructionTypesEnum.Split,
+    ValidInstructionTypesEnum.Authorize,
+    ValidInstructionTypesEnum.SetComputeUnitLimit,
+    ValidInstructionTypesEnum.SetPriorityFee,
+    ValidInstructionTypesEnum.MintTo,
+    ValidInstructionTypesEnum.Burn,
+    ValidInstructionTypesEnum.Approve,
+    ValidInstructionTypesEnum.DepositSol,
+    ValidInstructionTypesEnum.WithdrawStake,
+    ValidInstructionTypesEnum.CustomInstruction,
+    ValidInstructionTypesEnum.PermissionlessThawIdempotent,
+];
+/** Const to check the order of the Wallet Init instructions when decode */
+export const walletInitInstructionIndexes = {
+    Create: 0,
+    InitializeNonceAccount: 1,
+    Memo: 2,
+};
+/** Const to check the order of the Staking Activate instructions when decode */
+export const stakingActivateInstructionsIndexes = {
+    Create: 0,
+    Initialize: 1,
+    Delegate: 2,
+    Memo: 3,
+};
+/** Const to check the order of the Marinade Staking Activate instructions when decode */
+export const marinadeStakingActivateInstructionsIndexes = {
+    Create: 0,
+    Initialize: 1,
+    Memo: 2,
+};
+/** Const to check the order of the Jito Staking Activate instructions when decode */
+export const jitoStakingActivateInstructionsIndexes = {
+    DepositSol: 0,
+};
+/** Const to check the order of the Jito Staking Activate instructions when decode */
+export const jitoStakingActivateWithATAInstructionsIndexes = {
+    InitializeAssociatedTokenAccount: 0,
+    DepositSol: 1,
+};
+/** Const to check the order of the Jito Staking Activate instructions when decode */
+export const jitoStakingDeactivateInstructionsIndexes = {
+    Approve: 0,
+    Create: 1,
+    WithdrawStake: 2,
+};
+/** Const to check the order of the Staking Authorize instructions when decode */
+export const stakingAuthorizeInstructionsIndexes = {
+    Authorize: 0,
+};
+/** Const to check the order of the Staking Delegate instructions when decode */
+export const stakingDelegateInstructionsIndexes = {
+    Delegate: 0,
+};
+/** Const to check the order of the Staking Deactivate instructions when decode */
+export const stakingDeactivateInstructionsIndexes = {
+    Deactivate: 0,
+    Memo: 1,
+};
+/** Const to check the order of the Marinade Staking Deactivate instructions when decode */
+export const marinadeStakingDeactivateInstructionsIndexes = {
+    Transfer: 0,
+    Memo: 1,
+};
+/** Const to check the order of the Partial Staking Deactivate instructions when decoded */
+export const stakingPartialDeactivateInstructionsIndexes = {
+    Transfer: 0,
+    Allocate: 1,
+    Assign: 2,
+    Split: 3,
+    Deactivate: 4,
+    Memo: 5,
+};
+/** Const to check the order of the Staking Withdraw instructions when decode */
+export const stakingWithdrawInstructionsIndexes = {
+    Withdraw: 0,
+    Memo: 1,
+};
+/** Const to check the order of the ATA init instructions when decode */
+export const ataInitInstructionIndexes = {
+    InitializeAssociatedTokenAccount: 0,
+    Memo: 1,
+};
+/** Const to check the order of the ATA init instructions when decode */
+export const ataCloseInstructionIndexes = {
+    CloseAssociatedTokenAccount: 0,
+};
+/** Const to check the order of the recover nested ATA instructions when decode */
+export const ataRecoverNestedInstructionIndexes = {
+    RecoverNestedAssociatedTokenAccount: 0,
+};
+export const nonceAdvanceInstruction = 'AdvanceNonceAccount';
+export const validInstructionData = '0a00000001000000';
+export const validInstructionData2 = '0a00000000000000';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/lib/constants.ts"],"names":[],"mappings":"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","sourcesContent":["import { ValidInstructionTypes } from './iface';\n\nexport const MEMO_PROGRAM_PK = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';\n\nexport const SEED_LENGTH = 32;\n\nexport const MAX_MEMO_LENGTH = 130;\nexport const STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT = 2282880;\n\nexport const UNAVAILABLE_TEXT = 'UNAVAILABLE';\n\n/**\n * Sysvar instructions account address — used by Token-2022 confidential transfer\n * instructions to locate inline proof verification instructions in the same transaction.\n */\nexport const INSTRUCTIONS_SYSVAR_ADDRESS = 'Sysvar1nstructions1111111111111111111111111';\n\n/**\n * Canonical on-chain program id of the zk-elgamal-proof program.\n *\n * This is the same across mainnet, devnet, and testnet — it is a native\n * built-in program. Callers can override via ConfidentialTransferBuilder\n * .zkProofProgramId() if targeting a custom deployment.\n *\n * Note: The deprecated zk-token-proof program id is\n * `ZkTokenProof1111111111111111111111111111111`.\n */\nexport const ZK_ELGAMAL_PROOF_PROGRAM_ID = 'ZkE1Gama1Proof11111111111111111111111111111';\n\n/**\n * Token-2022 confidential transfer extension discriminator (byte 0 of instruction data).\n */\nexport const CT_EXT_DISCRIMINATOR = 27;\n\n/**\n * Valid CT sub-instruction discriminators (byte 1 after CT_EXT_DISCRIMINATOR).\n * Used for transaction type detection (getTransactionType / deriveTransactionType).\n */\nexport const CT_SUB_DISCRIMINATORS = new Set<number>([\n  2, // ConfigureAccount\n  5, // Deposit\n  6, // Withdraw\n  7, // Transfer\n  8, // ApplyPendingBalance\n]);\n\n/**\n * Maximum over-the-wire size of a Solana transaction (in bytes)\n *\n * Source: https://github.com/anza-xyz/agave/blob/v2.1.13/sdk/packet/src/lib.rs#L27-L29\n *\n * Calculation:\n * - IPv6 minimum MTU: 1280 bytes\n * - IPv6 header: 40 bytes\n * - Fragment/UDP header: 8 bytes\n * - Result: 1280 - 40 - 8 = 1232 bytes\n *\n * This limit is designed to avoid packet fragmentation on typical internet infrastructure.\n * Transactions exceeding this limit will fail to serialize with a RangeError during\n * the encoding of the transaction message.\n *\n * Reference: https://solana.com/docs/core/transactions#transaction-size\n */\nexport const SOLANA_TRANSACTION_MAX_SIZE = 1232;\n\nexport const JITO_STAKE_POOL_ADDRESS = 'Jito4APyf642JPZPx3hGc6WWJ8zPKtRbRs4P815Awbb';\nexport const JITOSOL_MINT_ADDRESS = 'J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn';\nexport const JITO_STAKE_POOL_RESERVE_ACCOUNT = 'BgKUXdS29YcHCFrPm5M8oLHiTzZaMDjsebggjoaQ6KFL';\nexport const JITO_STAKE_POOL_RESERVE_ACCOUNT_TESTNET = 'rrWBQqRqBXYZw3CmPCCcjFxQ2Ds4JFJd7oRQJ997dhz';\nexport const JITO_MANAGER_FEE_ACCOUNT = 'feeeFLLsam6xZJFc6UQFrHqkvVt4jfmVvi2BRLkUZ4i';\nexport const JITO_MANAGER_FEE_ACCOUNT_TESTNET = 'DH7tmjoQ5zjqcgfYJU22JqmXhP5EY1tkbYpgVWUS2oNo';\n\n/**\n * On-chain program id of the sRFC-37 Token ACL program. This single program gates every\n * allowlist/blocklist (DefaultAccountState) Token-2022 mint, so the value is generic and never\n * tied to a specific issuer.\n */\nexport const TOKEN_ACL_PROGRAM_ID = 'TACLkU6CiCdkQN2MjoyDkVg2yAH9zkxiHDsiztQ52TP';\n\n/**\n * Instruction discriminator (a single u8 byte) for the Token ACL `ThawPermissionlessIdempotent`\n * instruction.\n */\nexport const THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR = 9;\n\n/** PDA seed prefix (under the Token ACL program) for a mint's MintConfig account. */\nexport const TOKEN_ACL_MINT_CONFIG_SEED = 'MINT_CONFIG';\n/** PDA seed prefix (under the Token ACL program) for a token account's thaw flag account. */\nexport const TOKEN_ACL_FLAG_ACCOUNT_SEED = 'FLAG_ACCOUNT';\n/** PDA seed prefix (under the gating program) for a mint's thaw ExtraAccountMetaList account. */\nexport const TOKEN_ACL_THAW_EXTRA_METAS_SEED = 'thaw_extra_account_metas';\n\n// Sdk instructions, mainly to check decoded types.\nexport enum ValidInstructionTypesEnum {\n  AdvanceNonceAccount = 'AdvanceNonceAccount',\n  Create = 'Create',\n  InitializeNonceAccount = 'InitializeNonceAccount',\n  StakingInitialize = 'Initialize',\n  StakingDelegate = 'Delegate',\n  StakingDeactivate = 'Deactivate',\n  StakingWithdraw = 'Withdraw',\n  Transfer = 'Transfer',\n  TokenTransfer = 'TokenTransfer',\n  Memo = 'Memo',\n  InitializeAssociatedTokenAccount = 'InitializeAssociatedTokenAccount',\n  CloseAssociatedTokenAccount = 'CloseAssociatedTokenAccount',\n  RecoverNestedAssociatedTokenAccount = 'RecoverNestedAssociatedTokenAccount',\n  Allocate = 'Allocate',\n  Assign = 'Assign',\n  Split = 'Split',\n  Authorize = 'Authorize',\n  SetComputeUnitLimit = 'SetComputeUnitLimit',\n  SetPriorityFee = 'SetPriorityFee',\n  MintTo = 'MintTo',\n  Burn = 'Burn',\n  DepositSol = 'DepositSol',\n  WithdrawStake = 'WithdrawStake',\n  Approve = 'Approve',\n  CustomInstruction = 'CustomInstruction',\n  PermissionlessThawIdempotent = 'PermissionlessThawIdempotent',\n  // Confidential Transfer instruction types (Token-2022 CT extension + zk-elgamal-proof)\n  ConfigureConfidentialTransferAccount = 'ConfigureConfidentialTransferAccount',\n  ApplyPendingBalance = 'ApplyPendingBalance',\n  ConfidentialDeposit = 'ConfidentialDeposit',\n  ConfidentialWithdraw = 'ConfidentialWithdraw',\n  ConfidentialTransfer = 'ConfidentialTransfer',\n  VerifyPubkeyValidity = 'VerifyPubkeyValidity',\n  VerifyEqualityProof = 'VerifyEqualityProof',\n  VerifyValidityProof = 'VerifyValidityProof',\n  VerifyRangeProof = 'VerifyRangeProof',\n}\n\n// Internal instructions types\nexport enum InstructionBuilderTypes {\n  CreateNonceAccount = 'CreateNonceAccount',\n  StakingActivate = 'Activate',\n  StakingDeactivate = 'Deactivate',\n  StakingWithdraw = 'Withdraw',\n  Transfer = 'Transfer',\n  Memo = 'Memo',\n  NonceAdvance = 'NonceAdvance',\n  CreateAssociatedTokenAccount = 'CreateAssociatedTokenAccount',\n  CloseAssociatedTokenAccount = 'CloseAssociatedTokenAccount',\n  RecoverNestedAssociatedTokenAccount = 'RecoverNestedAssociatedTokenAccount',\n  TokenTransfer = 'TokenTransfer',\n  StakingAuthorize = 'Authorize',\n  StakingDelegate = 'Delegate',\n  SetComputeUnitLimit = 'SetComputeUnitLimit',\n  SetPriorityFee = 'SetPriorityFee',\n  MintTo = 'MintTo',\n  Burn = 'Burn',\n  CustomInstruction = 'CustomInstruction',\n  VersionedCustomInstruction = 'VersionedCustomInstruction',\n  Approve = 'Approve',\n  WithdrawStake = 'WithdrawStake',\n  PermissionlessThawIdempotent = 'PermissionlessThawIdempotent',\n  // Confidential Transfer instruction types (Token-2022 CT extension + zk-elgamal-proof)\n  ConfigureConfidentialTransferAccount = 'ConfigureConfidentialTransferAccount',\n  ApplyPendingBalance = 'ApplyPendingBalance',\n  ConfidentialDeposit = 'ConfidentialDeposit',\n  ConfidentialWithdraw = 'ConfidentialWithdraw',\n  ConfidentialTransfer = 'ConfidentialTransfer',\n  VerifyPubkeyValidity = 'VerifyPubkeyValidity',\n  VerifyEqualityProof = 'VerifyEqualityProof',\n  VerifyValidityProof = 'VerifyValidityProof',\n  VerifyRangeProof = 'VerifyRangeProof',\n}\n\nexport const VALID_SYSTEM_INSTRUCTION_TYPES: ValidInstructionTypes[] = [\n  ValidInstructionTypesEnum.AdvanceNonceAccount,\n  ValidInstructionTypesEnum.Create,\n  ValidInstructionTypesEnum.StakingInitialize,\n  ValidInstructionTypesEnum.StakingDelegate,\n  ValidInstructionTypesEnum.StakingDeactivate,\n  ValidInstructionTypesEnum.StakingWithdraw,\n  ValidInstructionTypesEnum.Transfer,\n  ValidInstructionTypesEnum.InitializeNonceAccount,\n  ValidInstructionTypesEnum.Memo,\n  ValidInstructionTypesEnum.InitializeAssociatedTokenAccount,\n  ValidInstructionTypesEnum.CloseAssociatedTokenAccount,\n  ValidInstructionTypesEnum.RecoverNestedAssociatedTokenAccount,\n  ValidInstructionTypesEnum.TokenTransfer,\n  ValidInstructionTypesEnum.Allocate,\n  ValidInstructionTypesEnum.Assign,\n  ValidInstructionTypesEnum.Split,\n  ValidInstructionTypesEnum.Authorize,\n  ValidInstructionTypesEnum.SetComputeUnitLimit,\n  ValidInstructionTypesEnum.SetPriorityFee,\n  ValidInstructionTypesEnum.MintTo,\n  ValidInstructionTypesEnum.Burn,\n  ValidInstructionTypesEnum.Approve,\n  ValidInstructionTypesEnum.DepositSol,\n  ValidInstructionTypesEnum.WithdrawStake,\n  ValidInstructionTypesEnum.CustomInstruction,\n  ValidInstructionTypesEnum.PermissionlessThawIdempotent,\n];\n\n/** Const to check the order of the Wallet Init instructions when decode */\nexport const walletInitInstructionIndexes = {\n  Create: 0,\n  InitializeNonceAccount: 1,\n  Memo: 2,\n} as const;\n\n/** Const to check the order of the Staking Activate instructions when decode */\nexport const stakingActivateInstructionsIndexes = {\n  Create: 0,\n  Initialize: 1,\n  Delegate: 2,\n  Memo: 3,\n} as const;\n\n/** Const to check the order of the Marinade Staking Activate instructions when decode */\nexport const marinadeStakingActivateInstructionsIndexes = {\n  Create: 0,\n  Initialize: 1,\n  Memo: 2,\n} as const;\n\n/** Const to check the order of the Jito Staking Activate instructions when decode */\nexport const jitoStakingActivateInstructionsIndexes = {\n  DepositSol: 0,\n} as const;\n\n/** Const to check the order of the Jito Staking Activate instructions when decode */\nexport const jitoStakingActivateWithATAInstructionsIndexes = {\n  InitializeAssociatedTokenAccount: 0,\n  DepositSol: 1,\n} as const;\n\n/** Const to check the order of the Jito Staking Activate instructions when decode */\nexport const jitoStakingDeactivateInstructionsIndexes = {\n  Approve: 0,\n  Create: 1,\n  WithdrawStake: 2,\n} as const;\n\n/** Const to check the order of the Staking Authorize instructions when decode */\nexport const stakingAuthorizeInstructionsIndexes = {\n  Authorize: 0,\n} as const;\n\n/** Const to check the order of the Staking Delegate instructions when decode */\nexport const stakingDelegateInstructionsIndexes = {\n  Delegate: 0,\n} as const;\n\n/** Const to check the order of the Staking Deactivate instructions when decode */\nexport const stakingDeactivateInstructionsIndexes = {\n  Deactivate: 0,\n  Memo: 1,\n} as const;\n\n/** Const to check the order of the Marinade Staking Deactivate instructions when decode */\nexport const marinadeStakingDeactivateInstructionsIndexes = {\n  Transfer: 0,\n  Memo: 1,\n} as const;\n\n/** Const to check the order of the Partial Staking Deactivate instructions when decoded */\nexport const stakingPartialDeactivateInstructionsIndexes = {\n  Transfer: 0,\n  Allocate: 1,\n  Assign: 2,\n  Split: 3,\n  Deactivate: 4,\n  Memo: 5,\n} as const;\n\n/** Const to check the order of the Staking Withdraw instructions when decode */\nexport const stakingWithdrawInstructionsIndexes = {\n  Withdraw: 0,\n  Memo: 1,\n} as const;\n\n/** Const to check the order of the ATA init instructions when decode */\nexport const ataInitInstructionIndexes = {\n  InitializeAssociatedTokenAccount: 0,\n  Memo: 1,\n} as const;\n\n/** Const to check the order of the ATA init instructions when decode */\nexport const ataCloseInstructionIndexes = {\n  CloseAssociatedTokenAccount: 0,\n} as const;\n\n/** Const to check the order of the recover nested ATA instructions when decode */\nexport const ataRecoverNestedInstructionIndexes = {\n  RecoverNestedAssociatedTokenAccount: 0,\n} as const;\n\nexport const nonceAdvanceInstruction = 'AdvanceNonceAccount';\nexport const validInstructionData = '0a00000001000000';\nexport const validInstructionData2 = '0a00000000000000';\n"]}

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

@@ -0,0 +1,72 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { SolInstruction, SolVersionedInstruction, TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { CustomInstruction, VersionedCustomInstruction, VersionedTransactionData } from './iface';
+/**
+ * Transaction builder for custom Solana instructions.
+ * Allows building transactions with any set of raw Solana instructions.
+ */
+export declare class CustomInstructionBuilder extends TransactionBuilder {
+    private _customInstructions;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /**
+     * Initialize the builder from an existing transaction
+     */
+    initBuilder(tx: Transaction): void;
+    /**
+     * Add a custom instruction to the transaction
+     * @param instruction - The custom instruction to add
+     * @returns This builder instance
+     */
+    addCustomInstruction(instruction: SolInstruction | SolVersionedInstruction): this;
+    /**
+     * Add multiple custom instructions to the transaction
+     * @param instructions - Array of custom instructions to add
+     * @returns This builder instance
+     */
+    addCustomInstructions(instructions: (SolInstruction | SolVersionedInstruction)[]): this;
+    /**
+     * Build transaction from deconstructed VersionedTransaction data
+     * @param data - VersionedTransactionData containing instructions, ALTs, and account keys
+     * @returns This builder instance
+     */
+    fromVersionedTransactionData(data: VersionedTransactionData): this;
+    /**
+     * Inject nonce advance instruction into versioned transaction data for durable nonce support.
+     * Reorders accounts so signers appear first (required by Solana MessageV0 format).
+     * @param data - Original versioned transaction data
+     * @returns Modified versioned transaction data with nonce advance instruction
+     * @private
+     */
+    private injectNonceAdvanceInstruction;
+    /**
+     * Clear all custom instructions and versioned transaction data
+     * @returns This builder instance
+     */
+    clearInstructions(): this;
+    /**
+     * Get the current custom instructions
+     * @returns Array of custom instructions
+     */
+    getInstructions(): (CustomInstruction | VersionedCustomInstruction)[];
+    /**
+     * Validate custom instruction format
+     * @param instruction - The instruction to validate
+     */
+    private validateInstruction;
+    /**
+     * Validate traditional SolInstruction format
+     * @param instruction - The traditional instruction to validate
+     */
+    private validateSolInstruction;
+    /**
+     * Validate versioned instruction format
+     * @param instruction - The versioned instruction to validate
+     */
+    private validateVersionedInstruction;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=customInstructionBuilder.d.ts.map