@bitgo-beta/sdk-coin-sol 7.6.4-beta.77 → 7.6.4-beta.771

package/dist/esm/lib/customInstructionBuilder.js

@@ -0,0 +1,385 @@
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { MessageV0, 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';
+import base58 from 'bs58';
+/**
+ * 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.
+     * Rebuilds the static account keys section by section (writable signers, read-only signers,
+     * writable non-signers, read-only non-signers), remaps every instruction index - static and
+     * lookup-table - to the new key order, and validates that the result compiles to a MessageV0.
+     * @param data - Original versioned transaction data
+     * @returns Modified versioned transaction data with the nonce advance instruction first
+     * @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 { numRequiredSignatures, numReadonlySignedAccounts, numReadonlyUnsignedAccounts } = data.messageHeader;
+        const oldStaticLen = data.staticAccountKeys.length;
+        if (numReadonlySignedAccounts > numRequiredSignatures ||
+            numRequiredSignatures + numReadonlyUnsignedAccounts > oldStaticLen) {
+            throw new BuildTransactionError(`Invalid message header: readonly counts (${numReadonlySignedAccounts}, ${numReadonlyUnsignedAccounts}) ` +
+                `are inconsistent with ${numRequiredSignatures} required signatures and ${oldStaticLen} static account keys`);
+        }
+        // Split the original static keys into the four MessageV0 header sections.
+        const writableSigners = data.staticAccountKeys.slice(0, numRequiredSignatures - numReadonlySignedAccounts);
+        const readonlySigners = data.staticAccountKeys.slice(numRequiredSignatures - numReadonlySignedAccounts, numRequiredSignatures);
+        const writableNonSigners = data.staticAccountKeys.slice(numRequiredSignatures, oldStaticLen - numReadonlyUnsignedAccounts);
+        const readonlyNonSigners = data.staticAccountKeys.slice(oldStaticLen - numReadonlyUnsignedAccounts);
+        // The nonce authority must be a signer for AdvanceNonceAccount. If it is already present
+        // as a non-signer, move it into the signers, keeping its writability (a writable
+        // non-signer becomes a writable signer, a read-only one a read-only signer).
+        const authorityIsSigner = writableSigners.includes(authWalletAddress) || readonlySigners.includes(authWalletAddress);
+        if (!authorityIsSigner) {
+            const asReadonlyNonSigner = readonlyNonSigners.indexOf(authWalletAddress);
+            const asWritableNonSigner = writableNonSigners.indexOf(authWalletAddress);
+            if (asReadonlyNonSigner >= 0) {
+                readonlyNonSigners.splice(asReadonlyNonSigner, 1);
+                readonlySigners.push(authWalletAddress);
+            }
+            else if (asWritableNonSigner >= 0) {
+                writableNonSigners.splice(asWritableNonSigner, 1);
+                writableSigners.push(authWalletAddress);
+            }
+            else {
+                // A brand-new authority is a read-only signer for AdvanceNonceAccount.
+                readonlySigners.push(authWalletAddress);
+            }
+        }
+        // The nonce account must be writable for AdvanceNonceAccount. If it is already present,
+        // keep it in place when writable, or move it into the writable section when read-only.
+        const nonceAsReadonlyNonSigner = readonlyNonSigners.indexOf(walletNonceAddress);
+        const nonceAsReadonlySigner = readonlySigners.indexOf(walletNonceAddress);
+        if (nonceAsReadonlyNonSigner >= 0) {
+            readonlyNonSigners.splice(nonceAsReadonlyNonSigner, 1);
+            writableNonSigners.push(walletNonceAddress);
+        }
+        else if (nonceAsReadonlySigner >= 0) {
+            readonlySigners.splice(nonceAsReadonlySigner, 1);
+            writableSigners.push(walletNonceAddress);
+        }
+        else if (!writableSigners.includes(walletNonceAddress) && !writableNonSigners.includes(walletNonceAddress)) {
+            writableNonSigners.push(walletNonceAddress);
+        }
+        // The system program and the recent blockhashes sysvar are read-only non-signers for
+        // AdvanceNonceAccount.
+        const isPresent = (key) => writableSigners.includes(key) ||
+            readonlySigners.includes(key) ||
+            writableNonSigners.includes(key) ||
+            readonlyNonSigners.includes(key);
+        if (!isPresent(SYSTEM_PROGRAM)) {
+            readonlyNonSigners.push(SYSTEM_PROGRAM);
+        }
+        if (!isPresent(SYSVAR_RECENT_BLOCKHASHES)) {
+            readonlyNonSigners.push(SYSVAR_RECENT_BLOCKHASHES);
+        }
+        const newStaticAccountKeys = [...writableSigners, ...readonlySigners, ...writableNonSigners, ...readonlyNonSigners];
+        // Build one full old-index to new-index map covering static and lookup-table indexes.
+        // Static indexes follow their key to its new position; lookup-table indexes, which are
+        // appended after the static keys, shift by the number of inserted static keys.
+        const indexMap = new Map();
+        data.staticAccountKeys.forEach((key, oldIdx) => indexMap.set(oldIdx, newStaticAccountKeys.indexOf(key)));
+        const shift = newStaticAccountKeys.length - oldStaticLen;
+        const lookupKeyCount = data.addressLookupTables.reduce((sum, alt) => sum + alt.writableIndexes.length + alt.readonlyIndexes.length, 0);
+        for (let i = oldStaticLen; i < oldStaticLen + lookupKeyCount; i++) {
+            indexMap.set(i, i + shift);
+        }
+        const remapIndex = (index) => {
+            const mapped = indexMap.get(index);
+            if (mapped === undefined) {
+                throw new BuildTransactionError(`Invalid account key index ${index} in versioned instruction`);
+            }
+            return mapped;
+        };
+        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 processed = {
+            ...data,
+            versionedInstructions: [
+                nonceAdvanceInstruction,
+                ...data.versionedInstructions.map((inst) => ({
+                    programIdIndex: remapIndex(inst.programIdIndex),
+                    accountKeyIndexes: inst.accountKeyIndexes.map(remapIndex),
+                    data: inst.data,
+                })),
+            ],
+            staticAccountKeys: newStaticAccountKeys,
+            messageHeader: {
+                numRequiredSignatures: writableSigners.length + readonlySigners.length,
+                numReadonlySignedAccounts: readonlySigners.length,
+                numReadonlyUnsignedAccounts: readonlyNonSigners.length,
+            },
+        };
+        this.validateInjectedMessage(processed);
+        return processed;
+    }
+    /**
+     * Validate the result of injectNonceAdvanceInstruction by compiling it: the MessageV0 built
+     * from the new keys, header, lookups and instructions must deserialize and contain no
+     * duplicate keys.
+     * @param data - Processed versioned transaction data
+     * @throws {BuildTransactionError} if the rebuilt message does not compile
+     * @private
+     */
+    validateInjectedMessage(data) {
+        if (new Set(data.staticAccountKeys).size !== data.staticAccountKeys.length) {
+            throw new BuildTransactionError('Injected nonce advance instruction produced duplicate account keys');
+        }
+        const message = new MessageV0({
+            header: data.messageHeader,
+            staticAccountKeys: data.staticAccountKeys.map((key) => new PublicKey(key)),
+            recentBlockhash: data.recentBlockhash ?? this._recentBlockhash,
+            compiledInstructions: data.versionedInstructions.map((instruction) => ({
+                programIdIndex: instruction.programIdIndex,
+                accountKeyIndexes: instruction.accountKeyIndexes,
+                data: Buffer.from(base58.decode(instruction.data)),
+            })),
+            addressTableLookups: data.addressLookupTables.map((alt) => ({
+                accountKey: new PublicKey(alt.accountKey),
+                writableIndexes: alt.writableIndexes,
+                readonlyIndexes: alt.readonlyIndexes,
+            })),
+        });
+        try {
+            MessageV0.deserialize(message.serialize());
+        }
+        catch (error) {
+            throw new BuildTransactionError(`Injected nonce advance instruction produced an invalid message: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    /**
+     * 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 { MessageV0, 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';\nimport base58 from 'bs58';\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   * Rebuilds the static account keys section by section (writable signers, read-only signers,\n   * writable non-signers, read-only non-signers), remaps every instruction index - static and\n   * lookup-table - to the new key order, and validates that the result compiles to a MessageV0.\n   * @param data - Original versioned transaction data\n   * @returns Modified versioned transaction data with the nonce advance instruction first\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 { numRequiredSignatures, numReadonlySignedAccounts, numReadonlyUnsignedAccounts } = data.messageHeader;\n    const oldStaticLen = data.staticAccountKeys.length;\n    if (\n      numReadonlySignedAccounts > numRequiredSignatures ||\n      numRequiredSignatures + numReadonlyUnsignedAccounts > oldStaticLen\n    ) {\n      throw new BuildTransactionError(\n        `Invalid message header: readonly counts (${numReadonlySignedAccounts}, ${numReadonlyUnsignedAccounts}) ` +\n          `are inconsistent with ${numRequiredSignatures} required signatures and ${oldStaticLen} static account keys`\n      );\n    }\n\n    // Split the original static keys into the four MessageV0 header sections.\n    const writableSigners = data.staticAccountKeys.slice(0, numRequiredSignatures - numReadonlySignedAccounts);\n    const readonlySigners = data.staticAccountKeys.slice(\n      numRequiredSignatures - numReadonlySignedAccounts,\n      numRequiredSignatures\n    );\n    const writableNonSigners = data.staticAccountKeys.slice(\n      numRequiredSignatures,\n      oldStaticLen - numReadonlyUnsignedAccounts\n    );\n    const readonlyNonSigners = data.staticAccountKeys.slice(oldStaticLen - numReadonlyUnsignedAccounts);\n\n    // The nonce authority must be a signer for AdvanceNonceAccount. If it is already present\n    // as a non-signer, move it into the signers, keeping its writability (a writable\n    // non-signer becomes a writable signer, a read-only one a read-only signer).\n    const authorityIsSigner =\n      writableSigners.includes(authWalletAddress) || readonlySigners.includes(authWalletAddress);\n    if (!authorityIsSigner) {\n      const asReadonlyNonSigner = readonlyNonSigners.indexOf(authWalletAddress);\n      const asWritableNonSigner = writableNonSigners.indexOf(authWalletAddress);\n      if (asReadonlyNonSigner >= 0) {\n        readonlyNonSigners.splice(asReadonlyNonSigner, 1);\n        readonlySigners.push(authWalletAddress);\n      } else if (asWritableNonSigner >= 0) {\n        writableNonSigners.splice(asWritableNonSigner, 1);\n        writableSigners.push(authWalletAddress);\n      } else {\n        // A brand-new authority is a read-only signer for AdvanceNonceAccount.\n        readonlySigners.push(authWalletAddress);\n      }\n    }\n\n    // The nonce account must be writable for AdvanceNonceAccount. If it is already present,\n    // keep it in place when writable, or move it into the writable section when read-only.\n    const nonceAsReadonlyNonSigner = readonlyNonSigners.indexOf(walletNonceAddress);\n    const nonceAsReadonlySigner = readonlySigners.indexOf(walletNonceAddress);\n    if (nonceAsReadonlyNonSigner >= 0) {\n      readonlyNonSigners.splice(nonceAsReadonlyNonSigner, 1);\n      writableNonSigners.push(walletNonceAddress);\n    } else if (nonceAsReadonlySigner >= 0) {\n      readonlySigners.splice(nonceAsReadonlySigner, 1);\n      writableSigners.push(walletNonceAddress);\n    } else if (!writableSigners.includes(walletNonceAddress) && !writableNonSigners.includes(walletNonceAddress)) {\n      writableNonSigners.push(walletNonceAddress);\n    }\n\n    // The system program and the recent blockhashes sysvar are read-only non-signers for\n    // AdvanceNonceAccount.\n    const isPresent = (key: string) =>\n      writableSigners.includes(key) ||\n      readonlySigners.includes(key) ||\n      writableNonSigners.includes(key) ||\n      readonlyNonSigners.includes(key);\n    if (!isPresent(SYSTEM_PROGRAM)) {\n      readonlyNonSigners.push(SYSTEM_PROGRAM);\n    }\n    if (!isPresent(SYSVAR_RECENT_BLOCKHASHES)) {\n      readonlyNonSigners.push(SYSVAR_RECENT_BLOCKHASHES);\n    }\n\n    const newStaticAccountKeys = [...writableSigners, ...readonlySigners, ...writableNonSigners, ...readonlyNonSigners];\n\n    // Build one full old-index to new-index map covering static and lookup-table indexes.\n    // Static indexes follow their key to its new position; lookup-table indexes, which are\n    // appended after the static keys, shift by the number of inserted static keys.\n    const indexMap = new Map<number, number>();\n    data.staticAccountKeys.forEach((key, oldIdx) => indexMap.set(oldIdx, newStaticAccountKeys.indexOf(key)));\n    const shift = newStaticAccountKeys.length - oldStaticLen;\n    const lookupKeyCount = data.addressLookupTables.reduce(\n      (sum, alt) => sum + alt.writableIndexes.length + alt.readonlyIndexes.length,\n      0\n    );\n    for (let i = oldStaticLen; i < oldStaticLen + lookupKeyCount; i++) {\n      indexMap.set(i, i + shift);\n    }\n    const remapIndex = (index: number): number => {\n      const mapped = indexMap.get(index);\n      if (mapped === undefined) {\n        throw new BuildTransactionError(`Invalid account key index ${index} in versioned instruction`);\n      }\n      return mapped;\n    };\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 processed: VersionedTransactionData = {\n      ...data,\n      versionedInstructions: [\n        nonceAdvanceInstruction,\n        ...data.versionedInstructions.map((inst) => ({\n          programIdIndex: remapIndex(inst.programIdIndex),\n          accountKeyIndexes: inst.accountKeyIndexes.map(remapIndex),\n          data: inst.data,\n        })),\n      ],\n      staticAccountKeys: newStaticAccountKeys,\n      messageHeader: {\n        numRequiredSignatures: writableSigners.length + readonlySigners.length,\n        numReadonlySignedAccounts: readonlySigners.length,\n        numReadonlyUnsignedAccounts: readonlyNonSigners.length,\n      },\n    };\n\n    this.validateInjectedMessage(processed);\n    return processed;\n  }\n\n  /**\n   * Validate the result of injectNonceAdvanceInstruction by compiling it: the MessageV0 built\n   * from the new keys, header, lookups and instructions must deserialize and contain no\n   * duplicate keys.\n   * @param data - Processed versioned transaction data\n   * @throws {BuildTransactionError} if the rebuilt message does not compile\n   * @private\n   */\n  private validateInjectedMessage(data: VersionedTransactionData): void {\n    if (new Set(data.staticAccountKeys).size !== data.staticAccountKeys.length) {\n      throw new BuildTransactionError('Injected nonce advance instruction produced duplicate account keys');\n    }\n\n    const message = new MessageV0({\n      header: data.messageHeader,\n      staticAccountKeys: data.staticAccountKeys.map((key) => new PublicKey(key)),\n      recentBlockhash: data.recentBlockhash ?? this._recentBlockhash,\n      compiledInstructions: data.versionedInstructions.map((instruction) => ({\n        programIdIndex: instruction.programIdIndex,\n        accountKeyIndexes: instruction.accountKeyIndexes,\n        data: Buffer.from(base58.decode(instruction.data)),\n      })),\n      addressTableLookups: data.addressLookupTables.map((alt) => ({\n        accountKey: new PublicKey(alt.accountKey),\n        writableIndexes: alt.writableIndexes,\n        readonlyIndexes: alt.readonlyIndexes,\n      })),\n    });\n\n    try {\n      MessageV0.deserialize(message.serialize());\n    } catch (error) {\n      throw new BuildTransactionError(\n        `Injected nonce advance instruction produced an invalid message: ${\n          error instanceof Error ? error.message : error\n        }`\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":"AASA,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;AA0MD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,6BAA6B,GAAG,4BAA4B,CAoJzG"}