@bitgo-beta/sdk-coin-sol 7.6.4-beta.27 → 7.6.4-beta.270

package/dist/esm/lib/constants.js

@@ -0,0 +1,186 @@
+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';
+/**
+ * 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';
+// 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["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 || (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["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 || (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.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,
+];
+/** 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,
+};
+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 * 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// 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  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}\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  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}\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.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];\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\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

package/dist/esm/lib/customInstructionBuilder.js

@@ -0,0 +1,282 @@
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { PublicKey, SystemProgram, SYSVAR_RECENT_BLOCKHASHES_PUBKEY } from '@solana/web3.js';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { InstructionBuilderTypes } from './constants';
+import { isSolLegacyInstruction } from './utils';
+import assert from 'assert';
+/**
+ * Transaction builder for custom Solana instructions.
+ * Allows building transactions with any set of raw Solana instructions.
+ */
+export class CustomInstructionBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._customInstructions = [];
+    }
+    get transactionType() {
+        return TransactionType.CustomTx;
+    }
+    /**
+     * Initialize the builder from an existing transaction
+     */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.CustomInstruction) {
+                const customInstruction = instruction;
+                this.addCustomInstruction(customInstruction.params);
+            }
+            else if (instruction.type === InstructionBuilderTypes.VersionedCustomInstruction) {
+                const versionedCustomInstruction = instruction;
+                this.addCustomInstruction(versionedCustomInstruction.params);
+            }
+        }
+    }
+    /**
+     * Add a custom instruction to the transaction
+     * @param instruction - The custom instruction to add
+     * @returns This builder instance
+     */
+    addCustomInstruction(instruction) {
+        this.validateInstruction(instruction);
+        if (isSolLegacyInstruction(instruction)) {
+            const customInstruction = {
+                type: InstructionBuilderTypes.CustomInstruction,
+                params: instruction,
+            };
+            this._customInstructions.push(customInstruction);
+        }
+        else {
+            const versionedCustomInstruction = {
+                type: InstructionBuilderTypes.VersionedCustomInstruction,
+                params: instruction,
+            };
+            this._customInstructions.push(versionedCustomInstruction);
+        }
+        return this;
+    }
+    /**
+     * Add multiple custom instructions to the transaction
+     * @param instructions - Array of custom instructions to add
+     * @returns This builder instance
+     */
+    addCustomInstructions(instructions) {
+        if (!Array.isArray(instructions)) {
+            throw new BuildTransactionError('Instructions must be an array');
+        }
+        for (const instruction of instructions) {
+            this.addCustomInstruction(instruction);
+        }
+        return this;
+    }
+    /**
+     * Build transaction from deconstructed VersionedTransaction data
+     * @param data - VersionedTransactionData containing instructions, ALTs, and account keys
+     * @returns This builder instance
+     */
+    fromVersionedTransactionData(data) {
+        try {
+            if (!data || typeof data !== 'object') {
+                throw new BuildTransactionError('VersionedTransactionData must be a valid object');
+            }
+            if (!Array.isArray(data.versionedInstructions) || data.versionedInstructions.length === 0) {
+                throw new BuildTransactionError('versionedInstructions must be a non-empty array');
+            }
+            if (!Array.isArray(data.addressLookupTables)) {
+                throw new BuildTransactionError('addressLookupTables must be an array');
+            }
+            if (!Array.isArray(data.staticAccountKeys) || data.staticAccountKeys.length === 0) {
+                throw new BuildTransactionError('staticAccountKeys must be a non-empty array');
+            }
+            if (!data.messageHeader || typeof data.messageHeader !== 'object') {
+                throw new BuildTransactionError('messageHeader must be a valid object');
+            }
+            if (typeof data.messageHeader.numRequiredSignatures !== 'number' ||
+                data.messageHeader.numRequiredSignatures < 0) {
+                throw new BuildTransactionError('messageHeader.numRequiredSignatures must be a non-negative number');
+            }
+            if (typeof data.messageHeader.numReadonlySignedAccounts !== 'number' ||
+                data.messageHeader.numReadonlySignedAccounts < 0) {
+                throw new BuildTransactionError('messageHeader.numReadonlySignedAccounts must be a non-negative number');
+            }
+            if (typeof data.messageHeader.numReadonlyUnsignedAccounts !== 'number' ||
+                data.messageHeader.numReadonlyUnsignedAccounts < 0) {
+                throw new BuildTransactionError('messageHeader.numReadonlyUnsignedAccounts must be a non-negative number');
+            }
+            let processedData = data;
+            if (this._nonceInfo && this._nonceInfo.params) {
+                processedData = this.injectNonceAdvanceInstruction(data);
+            }
+            this.addCustomInstructions(processedData.versionedInstructions);
+            if (!this._transaction) {
+                this._transaction = new Transaction(this._coinConfig);
+            }
+            this._transaction.setVersionedTransactionData(processedData);
+            this._transaction.setTransactionType(TransactionType.CustomTx);
+            if (!this._sender && processedData.staticAccountKeys.length > 0) {
+                this._sender = processedData.staticAccountKeys[0];
+            }
+            return this;
+        }
+        catch (error) {
+            if (error instanceof BuildTransactionError) {
+                throw error;
+            }
+            throw new BuildTransactionError(`Failed to process versioned transaction data: ${error.message}`);
+        }
+    }
+    /**
+     * 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
+     */
+    injectNonceAdvanceInstruction(data) {
+        const { walletNonceAddress, authWalletAddress } = this._nonceInfo.params;
+        const SYSTEM_PROGRAM = SystemProgram.programId.toBase58();
+        const SYSVAR_RECENT_BLOCKHASHES = SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();
+        const numSigners = data.messageHeader.numRequiredSignatures;
+        const originalSigners = data.staticAccountKeys.slice(0, numSigners);
+        const originalNonSigners = data.staticAccountKeys.slice(numSigners);
+        if (!originalSigners.includes(authWalletAddress)) {
+            originalSigners.push(authWalletAddress);
+        }
+        const nonSigners = [...originalNonSigners];
+        const allKeys = [...originalSigners, ...originalNonSigners];
+        if (!allKeys.includes(SYSTEM_PROGRAM))
+            nonSigners.push(SYSTEM_PROGRAM);
+        if (!allKeys.includes(walletNonceAddress))
+            nonSigners.push(walletNonceAddress);
+        if (!allKeys.includes(SYSVAR_RECENT_BLOCKHASHES))
+            nonSigners.push(SYSVAR_RECENT_BLOCKHASHES);
+        const newStaticAccountKeys = [...originalSigners, ...nonSigners];
+        const nonceAdvanceInstruction = {
+            programIdIndex: newStaticAccountKeys.indexOf(SYSTEM_PROGRAM),
+            accountKeyIndexes: [
+                newStaticAccountKeys.indexOf(walletNonceAddress),
+                newStaticAccountKeys.indexOf(SYSVAR_RECENT_BLOCKHASHES),
+                newStaticAccountKeys.indexOf(authWalletAddress),
+            ],
+            data: '6vx8P', // SystemProgram AdvanceNonceAccount (0x04000000) in base58
+        };
+        const indexMap = new Map(data.staticAccountKeys.map((key, oldIdx) => [oldIdx, newStaticAccountKeys.indexOf(key)]));
+        const remappedInstructions = data.versionedInstructions.map((inst) => ({
+            programIdIndex: indexMap.get(inst.programIdIndex) ?? inst.programIdIndex,
+            accountKeyIndexes: inst.accountKeyIndexes.map((idx) => indexMap.get(idx) ?? idx),
+            data: inst.data,
+        }));
+        return {
+            ...data,
+            versionedInstructions: [nonceAdvanceInstruction, ...remappedInstructions],
+            staticAccountKeys: newStaticAccountKeys,
+            messageHeader: {
+                ...data.messageHeader,
+                numRequiredSignatures: originalSigners.length,
+            },
+        };
+    }
+    /**
+     * Clear all custom instructions and versioned transaction data
+     * @returns This builder instance
+     */
+    clearInstructions() {
+        this._customInstructions = [];
+        if (this._transaction) {
+            this._transaction.setVersionedTransactionData(undefined);
+        }
+        return this;
+    }
+    /**
+     * Get the current custom instructions
+     * @returns Array of custom instructions
+     */
+    getInstructions() {
+        return [...this._customInstructions];
+    }
+    /**
+     * Validate custom instruction format
+     * @param instruction - The instruction to validate
+     */
+    validateInstruction(instruction) {
+        if (!instruction) {
+            throw new BuildTransactionError('Instruction cannot be null or undefined');
+        }
+        if (isSolLegacyInstruction(instruction)) {
+            this.validateSolInstruction(instruction);
+        }
+        else {
+            this.validateVersionedInstruction(instruction);
+        }
+    }
+    /**
+     * Validate traditional SolInstruction format
+     * @param instruction - The traditional instruction to validate
+     */
+    validateSolInstruction(instruction) {
+        if (!instruction.programId || typeof instruction.programId !== 'string') {
+            throw new BuildTransactionError('Instruction must have a valid programId string');
+        }
+        // Validate that programId is a valid Solana public key
+        try {
+            new PublicKey(instruction.programId);
+        }
+        catch (error) {
+            throw new BuildTransactionError('Invalid programId format');
+        }
+        if (!instruction.keys || !Array.isArray(instruction.keys)) {
+            throw new BuildTransactionError('Instruction must have valid keys array');
+        }
+        // Validate each key
+        for (const key of instruction.keys) {
+            if (!key.pubkey || typeof key.pubkey !== 'string') {
+                throw new BuildTransactionError('Each key must have a valid pubkey string');
+            }
+            try {
+                new PublicKey(key.pubkey);
+            }
+            catch (error) {
+                throw new BuildTransactionError('Invalid pubkey format in keys');
+            }
+            if (typeof key.isSigner !== 'boolean') {
+                throw new BuildTransactionError('Each key must have a boolean isSigner field');
+            }
+            if (typeof key.isWritable !== 'boolean') {
+                throw new BuildTransactionError('Each key must have a boolean isWritable field');
+            }
+        }
+        if (instruction.data === undefined || typeof instruction.data !== 'string') {
+            throw new BuildTransactionError('Instruction must have valid data string');
+        }
+    }
+    /**
+     * Validate versioned instruction format
+     * @param instruction - The versioned instruction to validate
+     */
+    validateVersionedInstruction(instruction) {
+        if (typeof instruction.programIdIndex !== 'number' || instruction.programIdIndex < 0) {
+            throw new BuildTransactionError('Versioned instruction must have a valid programIdIndex number');
+        }
+        if (!instruction.accountKeyIndexes || !Array.isArray(instruction.accountKeyIndexes)) {
+            throw new BuildTransactionError('Versioned instruction must have valid accountKeyIndexes array');
+        }
+        // Validate each account key index
+        for (const index of instruction.accountKeyIndexes) {
+            if (typeof index !== 'number' || index < 0) {
+                throw new BuildTransactionError('Each accountKeyIndex must be a non-negative number');
+            }
+        }
+        if (instruction.data === undefined || typeof instruction.data !== 'string') {
+            throw new BuildTransactionError('Versioned instruction must have valid data string');
+        }
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._customInstructions.length > 0, 'At least one custom instruction must be specified');
+        // Set the instructions data to our custom instructions
+        this._instructionsData = [...this._customInstructions];
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customInstructionBuilder.js","sourceRoot":"","sources":["../../../src/lib/customInstructionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BuildTransactionError, SolInstruction, SolVersionedInstruction, TransactionType } from '@bitgo-beta/sdk-core';\nimport { PublicKey, SystemProgram, SYSVAR_RECENT_BLOCKHASHES_PUBKEY } from '@solana/web3.js';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { InstructionBuilderTypes } from './constants';\nimport { CustomInstruction, VersionedCustomInstruction, VersionedTransactionData } from './iface';\nimport { isSolLegacyInstruction } from './utils';\nimport assert from 'assert';\n\n/**\n * Transaction builder for custom Solana instructions.\n * Allows building transactions with any set of raw Solana instructions.\n */\nexport class CustomInstructionBuilder extends TransactionBuilder {\n  private _customInstructions: (CustomInstruction | VersionedCustomInstruction)[] = [];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.CustomTx;\n  }\n\n  /**\n   * Initialize the builder from an existing transaction\n   */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n\n    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.CustomInstruction) {\n        const customInstruction = instruction as CustomInstruction;\n        this.addCustomInstruction(customInstruction.params);\n      } else if (instruction.type === InstructionBuilderTypes.VersionedCustomInstruction) {\n        const versionedCustomInstruction = instruction as VersionedCustomInstruction;\n        this.addCustomInstruction(versionedCustomInstruction.params);\n      }\n    }\n  }\n\n  /**\n   * Add a custom instruction to the transaction\n   * @param instruction - The custom instruction to add\n   * @returns This builder instance\n   */\n  addCustomInstruction(instruction: SolInstruction | SolVersionedInstruction): this {\n    this.validateInstruction(instruction);\n\n    if (isSolLegacyInstruction(instruction)) {\n      const customInstruction: CustomInstruction = {\n        type: InstructionBuilderTypes.CustomInstruction,\n        params: instruction,\n      };\n      this._customInstructions.push(customInstruction);\n    } else {\n      const versionedCustomInstruction: VersionedCustomInstruction = {\n        type: InstructionBuilderTypes.VersionedCustomInstruction,\n        params: instruction,\n      };\n      this._customInstructions.push(versionedCustomInstruction);\n    }\n\n    return this;\n  }\n\n  /**\n   * Add multiple custom instructions to the transaction\n   * @param instructions - Array of custom instructions to add\n   * @returns This builder instance\n   */\n  addCustomInstructions(instructions: (SolInstruction | SolVersionedInstruction)[]): this {\n    if (!Array.isArray(instructions)) {\n      throw new BuildTransactionError('Instructions must be an array');\n    }\n    for (const instruction of instructions) {\n      this.addCustomInstruction(instruction);\n    }\n    return this;\n  }\n\n  /**\n   * Build transaction from deconstructed VersionedTransaction data\n   * @param data - VersionedTransactionData containing instructions, ALTs, and account keys\n   * @returns This builder instance\n   */\n  fromVersionedTransactionData(data: VersionedTransactionData): this {\n    try {\n      if (!data || typeof data !== 'object') {\n        throw new BuildTransactionError('VersionedTransactionData must be a valid object');\n      }\n\n      if (!Array.isArray(data.versionedInstructions) || data.versionedInstructions.length === 0) {\n        throw new BuildTransactionError('versionedInstructions must be a non-empty array');\n      }\n\n      if (!Array.isArray(data.addressLookupTables)) {\n        throw new BuildTransactionError('addressLookupTables must be an array');\n      }\n\n      if (!Array.isArray(data.staticAccountKeys) || data.staticAccountKeys.length === 0) {\n        throw new BuildTransactionError('staticAccountKeys must be a non-empty array');\n      }\n\n      if (!data.messageHeader || typeof data.messageHeader !== 'object') {\n        throw new BuildTransactionError('messageHeader must be a valid object');\n      }\n      if (\n        typeof data.messageHeader.numRequiredSignatures !== 'number' ||\n        data.messageHeader.numRequiredSignatures < 0\n      ) {\n        throw new BuildTransactionError('messageHeader.numRequiredSignatures must be a non-negative number');\n      }\n      if (\n        typeof data.messageHeader.numReadonlySignedAccounts !== 'number' ||\n        data.messageHeader.numReadonlySignedAccounts < 0\n      ) {\n        throw new BuildTransactionError('messageHeader.numReadonlySignedAccounts must be a non-negative number');\n      }\n      if (\n        typeof data.messageHeader.numReadonlyUnsignedAccounts !== 'number' ||\n        data.messageHeader.numReadonlyUnsignedAccounts < 0\n      ) {\n        throw new BuildTransactionError('messageHeader.numReadonlyUnsignedAccounts must be a non-negative number');\n      }\n\n      let processedData = data;\n      if (this._nonceInfo && this._nonceInfo.params) {\n        processedData = this.injectNonceAdvanceInstruction(data);\n      }\n\n      this.addCustomInstructions(processedData.versionedInstructions);\n\n      if (!this._transaction) {\n        this._transaction = new Transaction(this._coinConfig);\n      }\n      this._transaction.setVersionedTransactionData(processedData);\n\n      this._transaction.setTransactionType(TransactionType.CustomTx);\n\n      if (!this._sender && processedData.staticAccountKeys.length > 0) {\n        this._sender = processedData.staticAccountKeys[0];\n      }\n\n      return this;\n    } catch (error) {\n      if (error instanceof BuildTransactionError) {\n        throw error;\n      }\n      throw new BuildTransactionError(`Failed to process versioned transaction data: ${error.message}`);\n    }\n  }\n\n  /**\n   * Inject nonce advance instruction into versioned transaction data for durable nonce support.\n   * Reorders accounts so signers appear first (required by Solana MessageV0 format).\n   * @param data - Original versioned transaction data\n   * @returns Modified versioned transaction data with nonce advance instruction\n   * @private\n   */\n  private injectNonceAdvanceInstruction(data: VersionedTransactionData): VersionedTransactionData {\n    const { walletNonceAddress, authWalletAddress } = this._nonceInfo!.params;\n    const SYSTEM_PROGRAM = SystemProgram.programId.toBase58();\n    const SYSVAR_RECENT_BLOCKHASHES = SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();\n\n    const numSigners = data.messageHeader.numRequiredSignatures;\n    const originalSigners = data.staticAccountKeys.slice(0, numSigners);\n    const originalNonSigners = data.staticAccountKeys.slice(numSigners);\n\n    if (!originalSigners.includes(authWalletAddress)) {\n      originalSigners.push(authWalletAddress);\n    }\n\n    const nonSigners = [...originalNonSigners];\n    const allKeys = [...originalSigners, ...originalNonSigners];\n\n    if (!allKeys.includes(SYSTEM_PROGRAM)) nonSigners.push(SYSTEM_PROGRAM);\n    if (!allKeys.includes(walletNonceAddress)) nonSigners.push(walletNonceAddress);\n    if (!allKeys.includes(SYSVAR_RECENT_BLOCKHASHES)) nonSigners.push(SYSVAR_RECENT_BLOCKHASHES);\n\n    const newStaticAccountKeys = [...originalSigners, ...nonSigners];\n\n    const nonceAdvanceInstruction: SolVersionedInstruction = {\n      programIdIndex: newStaticAccountKeys.indexOf(SYSTEM_PROGRAM),\n      accountKeyIndexes: [\n        newStaticAccountKeys.indexOf(walletNonceAddress),\n        newStaticAccountKeys.indexOf(SYSVAR_RECENT_BLOCKHASHES),\n        newStaticAccountKeys.indexOf(authWalletAddress),\n      ],\n      data: '6vx8P', // SystemProgram AdvanceNonceAccount (0x04000000) in base58\n    };\n\n    const indexMap = new Map(data.staticAccountKeys.map((key, oldIdx) => [oldIdx, newStaticAccountKeys.indexOf(key)]));\n    const remappedInstructions = data.versionedInstructions.map((inst) => ({\n      programIdIndex: indexMap.get(inst.programIdIndex) ?? inst.programIdIndex,\n      accountKeyIndexes: inst.accountKeyIndexes.map((idx) => indexMap.get(idx) ?? idx),\n      data: inst.data,\n    }));\n\n    return {\n      ...data,\n      versionedInstructions: [nonceAdvanceInstruction, ...remappedInstructions],\n      staticAccountKeys: newStaticAccountKeys,\n      messageHeader: {\n        ...data.messageHeader,\n        numRequiredSignatures: originalSigners.length,\n      },\n    };\n  }\n\n  /**\n   * Clear all custom instructions and versioned transaction data\n   * @returns This builder instance\n   */\n  clearInstructions(): this {\n    this._customInstructions = [];\n    if (this._transaction) {\n      this._transaction.setVersionedTransactionData(undefined);\n    }\n    return this;\n  }\n\n  /**\n   * Get the current custom instructions\n   * @returns Array of custom instructions\n   */\n  getInstructions(): (CustomInstruction | VersionedCustomInstruction)[] {\n    return [...this._customInstructions];\n  }\n\n  /**\n   * Validate custom instruction format\n   * @param instruction - The instruction to validate\n   */\n  private validateInstruction(instruction: SolInstruction | SolVersionedInstruction): void {\n    if (!instruction) {\n      throw new BuildTransactionError('Instruction cannot be null or undefined');\n    }\n\n    if (isSolLegacyInstruction(instruction)) {\n      this.validateSolInstruction(instruction);\n    } else {\n      this.validateVersionedInstruction(instruction);\n    }\n  }\n\n  /**\n   * Validate traditional SolInstruction format\n   * @param instruction - The traditional instruction to validate\n   */\n  private validateSolInstruction(instruction: SolInstruction): void {\n    if (!instruction.programId || typeof instruction.programId !== 'string') {\n      throw new BuildTransactionError('Instruction must have a valid programId string');\n    }\n\n    // Validate that programId is a valid Solana public key\n    try {\n      new PublicKey(instruction.programId);\n    } catch (error) {\n      throw new BuildTransactionError('Invalid programId format');\n    }\n\n    if (!instruction.keys || !Array.isArray(instruction.keys)) {\n      throw new BuildTransactionError('Instruction must have valid keys array');\n    }\n\n    // Validate each key\n    for (const key of instruction.keys) {\n      if (!key.pubkey || typeof key.pubkey !== 'string') {\n        throw new BuildTransactionError('Each key must have a valid pubkey string');\n      }\n\n      try {\n        new PublicKey(key.pubkey);\n      } catch (error) {\n        throw new BuildTransactionError('Invalid pubkey format in keys');\n      }\n\n      if (typeof key.isSigner !== 'boolean') {\n        throw new BuildTransactionError('Each key must have a boolean isSigner field');\n      }\n\n      if (typeof key.isWritable !== 'boolean') {\n        throw new BuildTransactionError('Each key must have a boolean isWritable field');\n      }\n    }\n\n    if (instruction.data === undefined || typeof instruction.data !== 'string') {\n      throw new BuildTransactionError('Instruction must have valid data string');\n    }\n  }\n\n  /**\n   * Validate versioned instruction format\n   * @param instruction - The versioned instruction to validate\n   */\n  private validateVersionedInstruction(instruction: SolVersionedInstruction): void {\n    if (typeof instruction.programIdIndex !== 'number' || instruction.programIdIndex < 0) {\n      throw new BuildTransactionError('Versioned instruction must have a valid programIdIndex number');\n    }\n\n    if (!instruction.accountKeyIndexes || !Array.isArray(instruction.accountKeyIndexes)) {\n      throw new BuildTransactionError('Versioned instruction must have valid accountKeyIndexes array');\n    }\n\n    // Validate each account key index\n    for (const index of instruction.accountKeyIndexes) {\n      if (typeof index !== 'number' || index < 0) {\n        throw new BuildTransactionError('Each accountKeyIndex must be a non-negative number');\n      }\n    }\n\n    if (instruction.data === undefined || typeof instruction.data !== 'string') {\n      throw new BuildTransactionError('Versioned instruction must have valid data string');\n    }\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._customInstructions.length > 0, 'At least one custom instruction must be specified');\n\n    // Set the instructions data to our custom instructions\n    this._instructionsData = [...this._customInstructions];\n\n    return await super.buildImplementation();\n  }\n}\n"]}

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

@@ -0,0 +1,21 @@
+import { TransactionExplanation as SolLibTransactionExplanation } from './iface';
+export interface ExplainTransactionWasmOptions {
+    txBase64: string;
+    feeInfo?: {
+        fee: string;
+    };
+    tokenAccountRentExemptAmount?: string;
+    coinName: string;
+}
+/**
+ * Standalone WASM-based transaction explanation.
+ *
+ * Parses the transaction via `parseTransaction(tx)` from @bitgo/wasm-solana,
+ * then derives the transaction type, extracts outputs/inputs, computes fees,
+ * and maps to BitGoJS TransactionExplanation format.
+ *
+ * The explain logic was ported from wasm-solana per the convention that
+ * `explainTransaction` belongs in BitGoJS, not in wasm-* packages.
+ */
+export declare function explainSolTransaction(params: ExplainTransactionWasmOptions): SolLibTransactionExplanation;
+//# sourceMappingURL=explainTransactionWasm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"explainTransactionWasm.d.ts","sourceRoot":"","sources":["../../../src/lib/explainTransactionWasm.ts"],"names":[],"mappings":"AAGA,OAAO,EAA0B,sBAAsB,IAAI,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAGzG,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAgKD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,6BAA6B,GAAG,4BAA4B,CAoJzG"}