@bitgo-beta/sdk-coin-sol 7.6.4-beta.40 → 7.6.4-beta.401

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"}