@bitgo-beta/sdk-coin-sol 7.6.4-beta.75 → 7.6.4-beta.751

package/dist/esm/lib/v1TransactionBuilder.js

@@ -0,0 +1,591 @@
+import { BaseTransactionBuilder, BuildTransactionError, SigningError, } from '@bitgo-beta/sdk-core';
+import { PublicKey, SystemProgram, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, Transaction as SolTransaction, TransactionInstruction, } from '@solana/web3.js';
+import base58 from 'bs58';
+import nacl from 'tweetnacl';
+import assert from 'assert';
+import { Transaction } from './transaction';
+import { InstructionBuilderTypes } from './constants';
+import { solInstructionFactory } from './solInstructionFactory';
+import { compileTransactionMessage } from './serialization/compileTransactionMessage';
+import { serializeWireTransaction } from './serialization/wire-transaction';
+import { parseWireTransaction } from './serialization/parseWireTransaction';
+import { decodeV1Message } from './serialization/codecs/v1/message';
+import { isValidAddress, isValidBlockId, isValidMemo, validateAddress } from './utils';
+import { KeyPair } from './keyPair';
+/**
+ * Construct an AdvanceNonceAccount instruction for a durable nonce.
+ *
+ * The v0 path receives this instruction from web3.js / the Rust wasm core
+ * (`NonceSource` durable variant); the v1 path compiles via
+ * `compileTransactionMessage`, so the nonce instruction must be constructed in
+ * TypeScript and injected into the compile input. The nonce authority
+ * (`authWalletAddress`) MUST sign the instruction — it becomes a required
+ * signer of the compiled message.
+ *
+ * @param nonceAddress - the durable nonce account address
+ * @param authWalletAddress - the nonce authority (gas-tank root in BitGo's model)
+ * @returns the AdvanceNonceAccount instruction
+ */
+export function buildAdvanceNonceAccountInstruction(nonceAddress, authWalletAddress) {
+    assert(nonceAddress, 'Missing nonceAddress param');
+    assert(authWalletAddress, 'Missing authWalletAddress param');
+    return SystemProgram.nonceAdvance({
+        noncePubkey: new PublicKey(nonceAddress),
+        authorizedPubkey: new PublicKey(authWalletAddress),
+    });
+}
+/**
+ * Map a v1 envelope instruction (index-based) into a web3.js TransactionInstruction
+ * (address-based), deriving each referenced account's signer/writable role from the
+ * message header (Solana role conventions: the last `numReadonlySignedAccounts`
+ * signers and last `numReadonlyUnsignedAccounts` non-signers are readonly).
+ *
+ * @param instruction - the envelope instruction (programIdIndex/accountKeyIndexes/data)
+ * @param data - the v1 envelope
+ * @returns the address-based instruction, ready for V1TransactionBuilder.addInstruction
+ */
+export function toV1TransactionInstruction(instruction, data) {
+    const { staticAccountKeys, messageHeader } = data;
+    const numRequiredSignatures = messageHeader.numRequiredSignatures;
+    const numAccounts = staticAccountKeys.length;
+    const isSigner = (index) => index < numRequiredSignatures;
+    const isWritable = (index) => isSigner(index)
+        ? index < numRequiredSignatures - messageHeader.numReadonlySignedAccounts
+        : index < numAccounts - messageHeader.numReadonlyUnsignedAccounts;
+    return new TransactionInstruction({
+        programId: new PublicKey(staticAccountKeys[instruction.programIdIndex]),
+        keys: instruction.accountKeyIndexes.map((accountIndex) => ({
+            pubkey: new PublicKey(staticAccountKeys[accountIndex]),
+            isSigner: isSigner(accountIndex),
+            isWritable: isWritable(accountIndex),
+        })),
+        data: Buffer.from(base58.decode(instruction.data)),
+    });
+}
+/**
+ * Inject an AdvanceNonceAccount instruction into a v1 envelope for durable nonce.
+ *
+ * v1 (SIMD-0296/0385) has no address lookup tables, so every account is a static
+ * key. The nonce authority MUST sign the AdvanceNonceAccount instruction (hard
+ * runtime requirement) and the nonce account MUST be writable; the system program
+ * and recent-blockhashes sysvar are readonly non-signers. The instruction is
+ * prepended and every instruction's account indexes are remapped to the rebuilt
+ * static key list; messageHeader grows accordingly so the wire-size estimate and
+ * account caps are correct.
+ *
+ * @param data - the v1 envelope (client-supplied, no nonce instruction)
+ * @param durableNonceParams - walletNonceAddress + authWalletAddress (gas-tank root)
+ * @returns a copy of the envelope with the nonce instruction injected
+ * @edge if the envelope already contains an AdvanceNonceAccount instruction, returns
+ *   the envelope unchanged (idempotent - a durable-aware client may supply it)
+ */
+export function injectV1NonceAdvanceInstruction(data, durableNonceParams) {
+    const { walletNonceAddress, authWalletAddress } = durableNonceParams;
+    const SYSTEM_PROGRAM = SystemProgram.programId.toBase58();
+    const SYSVAR_RECENT_BLOCKHASHES = SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();
+    // Idempotence: a durable-aware client may already include the nonce instruction.
+    const hasNonceAdvance = data.versionedInstructions.some((instruction) => {
+        const program = data.staticAccountKeys[instruction.programIdIndex];
+        return program === SYSTEM_PROGRAM && Buffer.from(base58.decode(instruction.data))[0] === 4;
+    });
+    if (hasNonceAdvance) {
+        return data;
+    }
+    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 static keys into the four v1 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.
+    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 {
+            readonlySigners.push(authWalletAddress);
+        }
+    }
+    // The nonce account must be writable for AdvanceNonceAccount.
+    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 recent-blockhashes sysvar are readonly non-signers.
+    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];
+    // Remap every instruction index to the new key order (v1 has no lookup tables).
+    const indexMap = new Map();
+    data.staticAccountKeys.forEach((key, oldIdx) => indexMap.set(oldIdx, newStaticAccountKeys.indexOf(key)));
+    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', // base58 of SystemProgram AdvanceNonceAccount (0x04000000)
+    };
+    return {
+        ...data,
+        versionedInstructions: [
+            nonceAdvanceInstruction,
+            ...data.versionedInstructions.map((instruction) => ({
+                programIdIndex: remapIndex(instruction.programIdIndex),
+                accountKeyIndexes: instruction.accountKeyIndexes.map(remapIndex),
+                data: instruction.data,
+            })),
+        ],
+        staticAccountKeys: newStaticAccountKeys,
+        messageHeader: {
+            numRequiredSignatures: writableSigners.length + readonlySigners.length,
+            numReadonlySignedAccounts: readonlySigners.length,
+            numReadonlyUnsignedAccounts: readonlyNonSigners.length,
+        },
+    };
+}
+export class V1TransactionBuilder extends BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._instructionsData = [];
+        this._extraInstructions = [];
+        this._signers = [];
+        this._signatures = new Map();
+        this.transaction = new Transaction(_coinConfig);
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        return this.buildV1();
+    }
+    /**
+     * Assemble the v1 transaction: derive instructions, inject the durable-nonce
+     * instruction when present, compile the message, and assemble the signed
+     * wire in message-signer order.
+     *
+     * @returns {Transaction} The built transaction holding the v1 message and wire bytes
+     */
+    buildV1() {
+        assert(this._sender, new BuildTransactionError('sender is required before building'));
+        assert(this._recentBlockhash, new BuildTransactionError('recent blockhash is required before building'));
+        assert(this._transactionConfig, 'transactionConfig is required to build a v1 transaction');
+        const instructions = [];
+        // Durable nonce: the AdvanceNonceAccount instruction MUST be part of the
+        // message (a bare nonce hash without the instruction is invalid). It is
+        // placed first, matching the v0 web3.js convention.
+        if (this._nonceInfo) {
+            instructions.push(buildAdvanceNonceAccountInstruction(this._nonceInfo.params.walletNonceAddress, this._nonceInfo.params.authWalletAddress));
+        }
+        for (const instruction of this._instructionsData) {
+            instructions.push(...solInstructionFactory(instruction, this._zkProofProgramId));
+        }
+        if (this._memo) {
+            const memoData = {
+                type: InstructionBuilderTypes.Memo,
+                params: { memo: this._memo },
+            };
+            this._instructionsData.push(memoData);
+            instructions.push(...solInstructionFactory(memoData));
+        }
+        instructions.push(...this._extraInstructions);
+        const feePayer = this._feePayer ? new PublicKey(this._feePayer) : new PublicKey(this._sender);
+        const messageBytes = compileTransactionMessage({
+            version: 1,
+            instructions,
+            feePayer,
+            recentBlockhash: this._recentBlockhash,
+            transactionConfig: this._transactionConfig,
+        });
+        // Signer order comes from the compiled message: the first
+        // numSignerAccounts static accounts are the required signers (fee payer
+        // first, then the remaining signers in the compiled account order).
+        const decoded = decodeV1Message(messageBytes);
+        const signerAddresses = decoded.staticAccounts.slice(0, decoded.header.numSignerAccounts);
+        const signatures = [];
+        for (const address of signerAddresses) {
+            const keyPair = this._signers.find((signer) => signer.getKeys().pub === address);
+            if (keyPair) {
+                const secretKey = keyPair.getKeys(true).prv;
+                assert(secretKey instanceof Uint8Array, 'Missing private key');
+                signatures.push(nacl.sign.detached(messageBytes, secretKey));
+                continue;
+            }
+            const external = this._signatures.get(address);
+            if (external) {
+                signatures.push(external);
+                continue;
+            }
+            // Missing signature: zero-fill the slot so the wire shape stays valid
+            // for partial-sign flows; the transaction is not broadcastable until
+            // every required signer has a signature.
+            signatures.push(new Uint8Array(64));
+        }
+        const v1Wire = serializeWireTransaction(messageBytes, signatures);
+        this._transaction.v1TransactionBytes = v1Wire;
+        this._transaction.v1MessageBytes = messageBytes;
+        this._transaction.lamportsPerSignature = this._lamportsPerSignature;
+        // Populate a metadata-only SolTransaction so toJson / loadInputsAndOutputs
+        // work. The durable nonce is carried via nonceInfo, matching the v0 model.
+        const metaTx = new SolTransaction();
+        metaTx.feePayer = feePayer;
+        metaTx.recentBlockhash = this._recentBlockhash;
+        if (this._nonceInfo) {
+            metaTx.nonceInfo = {
+                nonce: this._recentBlockhash,
+                nonceInstruction: buildAdvanceNonceAccountInstruction(this._nonceInfo.params.walletNonceAddress, this._nonceInfo.params.authWalletAddress),
+            };
+        }
+        metaTx.add(...instructions);
+        this._transaction.solTransaction = metaTx;
+        this._transaction.setTransactionType(this.transactionType);
+        this._transaction.setInstructionsData(this._instructionsData);
+        this._transaction.loadInputsAndOutputs();
+        return this._transaction;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = new Transaction(this._coinConfig);
+        const wireBytes = new Uint8Array(Buffer.from(rawTransaction, 'base64'));
+        const { messageBytes } = parseWireTransaction(wireBytes);
+        tx.v1TransactionBytes = wireBytes;
+        tx.v1MessageBytes = messageBytes;
+        // Populate a metadata-only SolTransaction from the decoded message so
+        // toJson / loadInputsAndOutputs work.
+        const decoded = decodeV1Message(messageBytes);
+        tx.setTransactionType(this.transactionType);
+        const metaTx = new SolTransaction();
+        metaTx.feePayer = new PublicKey(decoded.staticAccounts[0]);
+        metaTx.recentBlockhash = decoded.blockhash;
+        const numWritableSigners = decoded.header.numSignerAccounts - decoded.header.numReadonlySignerAccounts;
+        const numWritableNonSigners = decoded.staticAccounts.length - decoded.header.numReadonlyNonSignerAccounts;
+        for (const compiled of decoded.compiledInstructions) {
+            metaTx.add(new TransactionInstruction({
+                programId: new PublicKey(decoded.staticAccounts[compiled.programAddressIndex]),
+                keys: compiled.accountIndices.map((index) => ({
+                    pubkey: new PublicKey(decoded.staticAccounts[index]),
+                    isSigner: index < decoded.header.numSignerAccounts,
+                    isWritable: index < numWritableSigners ||
+                        (index >= decoded.header.numSignerAccounts && index < numWritableNonSigners),
+                })),
+                data: Buffer.from(compiled.data),
+            }));
+        }
+        tx.solTransaction = metaTx;
+        return tx;
+    }
+    // region Getters and Setters
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    /** @inheritdoc */
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        this.validateKey(key);
+        this.checkDuplicatedSigner(key);
+        const prv = key.key;
+        const signer = new KeyPair({ prv: prv });
+        this._signers.push(signer);
+        return this._transaction;
+    }
+    /** @inheritDoc */
+    addSignature(publicKey, signature) {
+        this._signatures.set(publicKey.pub, new Uint8Array(signature));
+    }
+    /**
+     * Sets the sender of this transaction.
+     * This account will be responsible for paying transaction fees.
+     *
+     * @param {string} senderAddress the account that is sending this transaction
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    sender(senderAddress) {
+        validateAddress(senderAddress, 'sender');
+        this._sender = senderAddress;
+        return this;
+    }
+    /**
+     * Set the transaction nonce.
+     * Requires both optional params in order to use the durable nonce.
+     *
+     * @param {string} blockHash The latest blockHash or the durable nonce hash
+     * @param {DurableNonceParams} [durableNonceParams] An object containing the walletNonceAddress and the authWalletAddress (required for durable nonce)
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    nonce(blockHash, durableNonceParams) {
+        if (!blockHash || !isValidBlockId(blockHash)) {
+            throw new BuildTransactionError('Invalid or missing blockHash, got: ' + blockHash);
+        }
+        if (durableNonceParams) {
+            validateAddress(durableNonceParams.walletNonceAddress, 'walletNonceAddress');
+            validateAddress(durableNonceParams.authWalletAddress, 'authWalletAddress');
+            if (durableNonceParams.walletNonceAddress === durableNonceParams.authWalletAddress) {
+                throw new BuildTransactionError('Invalid params: walletNonceAddress cannot be equal to authWalletAddress');
+            }
+            this._nonceInfo = {
+                type: InstructionBuilderTypes.NonceAdvance,
+                params: durableNonceParams,
+            };
+        }
+        this._recentBlockhash = blockHash;
+        return this;
+    }
+    /**
+     * Set the intent instructions to build, using the shared instruction params
+     * representation consumed by `solInstructionFactory` (same as the v0 flows).
+     *
+     * @param {InstructionParams[]} instructions the instruction params
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    instructions(instructions) {
+        this._instructionsData = [...instructions];
+        return this;
+    }
+    /**
+     * Append a pre-built instruction (e.g. an envelope-derived instruction or a
+     * custom instruction) to the transaction.
+     *
+     * @param {TransactionInstruction} instruction the instruction to append
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    addInstruction(instruction) {
+        this._extraInstructions.push(instruction);
+        return this;
+    }
+    /**
+     * Set the v1 transaction config (compute unit limit, heap size, loaded
+     * accounts data size limit, and priority fee as total lamports). Required
+     * before building.
+     *
+     * @param {SolV1TransactionConfig} config the v1 transaction config
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    transactionConfig(config) {
+        this._transactionConfig = {
+            computeUnitLimit: config.computeUnitLimit ?? null,
+            heapSize: config.heapSize ?? null,
+            loadedAccountsDataSizeLimit: config.loadedAccountsDataSizeLimit ?? null,
+            priorityFee: config.priorityFee ?? null,
+        };
+        return this;
+    }
+    /**
+     * Initialize the builder from a client-supplied v1 envelope
+     * (SolVersionedTransactionData). Sets the fee payer from staticAccountKeys[0],
+     * coerces the transaction config, and converts each envelope instruction to an
+     * address-based TransactionInstruction via {@link toV1TransactionInstruction}.
+     *
+     * @param data - the v1 envelope
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    fromVersionedData(data) {
+        if (!data || typeof data !== 'object') {
+            throw new BuildTransactionError('VersionedTransactionData must be a valid object');
+        }
+        if (!Array.isArray(data.staticAccountKeys) || data.staticAccountKeys.length === 0) {
+            throw new BuildTransactionError('staticAccountKeys must be a non-empty array');
+        }
+        if (!Array.isArray(data.versionedInstructions)) {
+            throw new BuildTransactionError('versionedInstructions must be an array');
+        }
+        if (!data.messageHeader || typeof data.messageHeader !== 'object') {
+            throw new BuildTransactionError('messageHeader must be a valid object');
+        }
+        this._sender = data.staticAccountKeys[0];
+        this._transactionConfig = {
+            computeUnitLimit: data.transactionConfig?.computeUnitLimit ?? null,
+            heapSize: data.transactionConfig?.heapSize ?? null,
+            loadedAccountsDataSizeLimit: data.transactionConfig?.loadedAccountsDataSizeLimit ?? null,
+            priorityFee: data.transactionConfig?.priorityFee ?? null,
+        };
+        for (const instruction of data.versionedInstructions) {
+            this.addInstruction(toV1TransactionInstruction(instruction, data));
+        }
+        return this;
+    }
+    /**
+     * Set the priority fee (total lamports) on the v1 transaction config.
+     *
+     * @param {FeeOptions} feeOptions the priority fee
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    setPriorityFee(feeOptions) {
+        if (!this._transactionConfig) {
+            this._transactionConfig = {
+                computeUnitLimit: null,
+                heapSize: null,
+                loadedAccountsDataSizeLimit: null,
+                priorityFee: null,
+            };
+        }
+        this._transactionConfig.priorityFee = Number(feeOptions.amount);
+        return this;
+    }
+    /**
+     * Set the fee (lamports per signature) for fee estimation.
+     *
+     * @param {FeeOptions} feeOptions the fee
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    fee(feeOptions) {
+        this._lamportsPerSignature = Number(feeOptions.amount);
+        return this;
+    }
+    feePayer(feePayer) {
+        this._feePayer = feePayer;
+        return this;
+    }
+    /**
+     * Set the memo.
+     *
+     * @param {string} memo
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    memo(memo) {
+        this.validateMemo(memo);
+        this._memo = memo;
+        return this;
+    }
+    /**
+     * Override the zk-elgamal-proof program id.
+     *
+     * Defaults to the canonical on-chain program id (`ZkE1Gama1Proof111...`)
+     * which is the same across mainnet, devnet, and testnet. Override only
+     * when targeting a custom deployment.
+     *
+     * @param {string} programId base58 encoded program id
+     * @returns {V1TransactionBuilder} This transaction builder
+     */
+    zkProofProgramId(programId) {
+        assert(programId, 'Missing programId param');
+        this._zkProofProgramId = programId;
+        return this;
+    }
+    // endregion
+    // region Validators
+    /** @inheritdoc */
+    validateAddress(address, addressFormat) {
+        if (!isValidAddress(address.address)) {
+            throw new BuildTransactionError('Invalid address ' + address.address);
+        }
+    }
+    /** @inheritdoc */
+    validateKey(key) {
+        let keyPair;
+        try {
+            keyPair = new KeyPair({ prv: key.key });
+        }
+        catch {
+            throw new BuildTransactionError('Invalid key');
+        }
+        if (!keyPair.getKeys().prv) {
+            throw new BuildTransactionError('Invalid key');
+        }
+    }
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new BuildTransactionError('Invalid raw transaction');
+        }
+        try {
+            parseWireTransaction(new Uint8Array(Buffer.from(rawTransaction, 'base64')));
+        }
+        catch (e) {
+            throw new BuildTransactionError('Invalid raw transaction: ' + e.message);
+        }
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        this.validateSender();
+        this.validateNonce();
+    }
+    /** @inheritdoc */
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new BuildTransactionError('Value cannot be less than zero');
+        }
+    }
+    /**
+     * Validates the memo.
+     *
+     * @param {string} memo - the memo as string
+     */
+    validateMemo(memo) {
+        if (!memo) {
+            throw new BuildTransactionError('Invalid memo, got: ' + memo);
+        }
+        if (!isValidMemo(memo)) {
+            throw new BuildTransactionError('Memo is too long');
+        }
+    }
+    /**
+     * Validates that the given key is not already in this._signers.
+     *
+     * @param {BaseKey} key - The key to check
+     */
+    checkDuplicatedSigner(key) {
+        this._signers.forEach((kp) => {
+            if (kp.getKeys().prv === key.key) {
+                throw new SigningError('Duplicated signer: ' + key.key);
+            }
+        });
+    }
+    /**
+     * Validates that the sender field is defined.
+     */
+    validateSender() {
+        if (this._sender === undefined) {
+            throw new BuildTransactionError('Invalid transaction: missing sender');
+        }
+    }
+    /**
+     * Validates that the nonce field is defined.
+     */
+    validateNonce() {
+        if (this._recentBlockhash === undefined) {
+            throw new BuildTransactionError('Invalid transaction: missing nonce blockhash');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v1TransactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/v1TransactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import BigNumber from 'bignumber.js';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport {\n  BaseAddress,\n  BaseKey,\n  BaseTransactionBuilder,\n  BuildTransactionError,\n  FeeOptions,\n  PublicKey as BasePublicKey,\n  SigningError,\n  SolV1TransactionConfig,\n  SolVersionedTransactionData,\n  TransactionType,\n} from '@bitgo-beta/sdk-core';\nimport {\n  PublicKey,\n  SystemProgram,\n  SYSVAR_RECENT_BLOCKHASHES_PUBKEY,\n  Transaction as SolTransaction,\n  TransactionInstruction,\n} from '@solana/web3.js';\nimport base58 from 'bs58';\nimport nacl from 'tweetnacl';\nimport assert from 'assert';\nimport { Transaction } from './transaction';\nimport { InstructionBuilderTypes } from './constants';\nimport { InstructionParams, Memo, Nonce } from './iface';\nimport { solInstructionFactory } from './solInstructionFactory';\nimport { compileTransactionMessage } from './serialization/compileTransactionMessage';\nimport { serializeWireTransaction } from './serialization/wire-transaction';\nimport { parseWireTransaction } from './serialization/parseWireTransaction';\nimport { decodeV1Message } from './serialization/codecs/v1/message';\nimport { isValidAddress, isValidBlockId, isValidMemo, validateAddress } from './utils';\nimport { KeyPair } from './keyPair';\n\n/**\n * Construct an AdvanceNonceAccount instruction for a durable nonce.\n *\n * The v0 path receives this instruction from web3.js / the Rust wasm core\n * (`NonceSource` durable variant); the v1 path compiles via\n * `compileTransactionMessage`, so the nonce instruction must be constructed in\n * TypeScript and injected into the compile input. The nonce authority\n * (`authWalletAddress`) MUST sign the instruction — it becomes a required\n * signer of the compiled message.\n *\n * @param nonceAddress - the durable nonce account address\n * @param authWalletAddress - the nonce authority (gas-tank root in BitGo's model)\n * @returns the AdvanceNonceAccount instruction\n */\nexport function buildAdvanceNonceAccountInstruction(\n  nonceAddress: string,\n  authWalletAddress: string\n): TransactionInstruction {\n  assert(nonceAddress, 'Missing nonceAddress param');\n  assert(authWalletAddress, 'Missing authWalletAddress param');\n  return SystemProgram.nonceAdvance({\n    noncePubkey: new PublicKey(nonceAddress),\n    authorizedPubkey: new PublicKey(authWalletAddress),\n  });\n}\n\n/**\n * Map a v1 envelope instruction (index-based) into a web3.js TransactionInstruction\n * (address-based), deriving each referenced account's signer/writable role from the\n * message header (Solana role conventions: the last `numReadonlySignedAccounts`\n * signers and last `numReadonlyUnsignedAccounts` non-signers are readonly).\n *\n * @param instruction - the envelope instruction (programIdIndex/accountKeyIndexes/data)\n * @param data - the v1 envelope\n * @returns the address-based instruction, ready for V1TransactionBuilder.addInstruction\n */\nexport function toV1TransactionInstruction(\n  instruction: { programIdIndex: number; accountKeyIndexes: number[]; data: string },\n  data: SolVersionedTransactionData\n): TransactionInstruction {\n  const { staticAccountKeys, messageHeader } = data;\n  const numRequiredSignatures = messageHeader.numRequiredSignatures;\n  const numAccounts = staticAccountKeys.length;\n\n  const isSigner = (index: number): boolean => index < numRequiredSignatures;\n  const isWritable = (index: number): boolean =>\n    isSigner(index)\n      ? index < numRequiredSignatures - messageHeader.numReadonlySignedAccounts\n      : index < numAccounts - messageHeader.numReadonlyUnsignedAccounts;\n\n  return new TransactionInstruction({\n    programId: new PublicKey(staticAccountKeys[instruction.programIdIndex]),\n    keys: instruction.accountKeyIndexes.map((accountIndex) => ({\n      pubkey: new PublicKey(staticAccountKeys[accountIndex]),\n      isSigner: isSigner(accountIndex),\n      isWritable: isWritable(accountIndex),\n    })),\n    data: Buffer.from(base58.decode(instruction.data)),\n  });\n}\n\n/**\n * Inject an AdvanceNonceAccount instruction into a v1 envelope for durable nonce.\n *\n * v1 (SIMD-0296/0385) has no address lookup tables, so every account is a static\n * key. The nonce authority MUST sign the AdvanceNonceAccount instruction (hard\n * runtime requirement) and the nonce account MUST be writable; the system program\n * and recent-blockhashes sysvar are readonly non-signers. The instruction is\n * prepended and every instruction's account indexes are remapped to the rebuilt\n * static key list; messageHeader grows accordingly so the wire-size estimate and\n * account caps are correct.\n *\n * @param data - the v1 envelope (client-supplied, no nonce instruction)\n * @param durableNonceParams - walletNonceAddress + authWalletAddress (gas-tank root)\n * @returns a copy of the envelope with the nonce instruction injected\n * @edge if the envelope already contains an AdvanceNonceAccount instruction, returns\n *   the envelope unchanged (idempotent - a durable-aware client may supply it)\n */\nexport function injectV1NonceAdvanceInstruction(\n  data: SolVersionedTransactionData,\n  durableNonceParams: { walletNonceAddress: string; authWalletAddress: string }\n): SolVersionedTransactionData {\n  const { walletNonceAddress, authWalletAddress } = durableNonceParams;\n  const SYSTEM_PROGRAM = SystemProgram.programId.toBase58();\n  const SYSVAR_RECENT_BLOCKHASHES = SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();\n\n  // Idempotence: a durable-aware client may already include the nonce instruction.\n  const hasNonceAdvance = data.versionedInstructions.some((instruction) => {\n    const program = data.staticAccountKeys[instruction.programIdIndex];\n    return program === SYSTEM_PROGRAM && Buffer.from(base58.decode(instruction.data))[0] === 4;\n  });\n  if (hasNonceAdvance) {\n    return data;\n  }\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 static keys into the four v1 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.\n  const authorityIsSigner = 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      readonlySigners.push(authWalletAddress);\n    }\n  }\n\n  // The nonce account must be writable for AdvanceNonceAccount.\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 recent-blockhashes sysvar are readonly non-signers.\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  // Remap every instruction index to the new key order (v1 has no lookup tables).\n  const indexMap = new Map<number, number>();\n  data.staticAccountKeys.forEach((key, oldIdx) => indexMap.set(oldIdx, newStaticAccountKeys.indexOf(key)));\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 = {\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', // base58 of SystemProgram AdvanceNonceAccount (0x04000000)\n  };\n\n  return {\n    ...data,\n    versionedInstructions: [\n      nonceAdvanceInstruction,\n      ...data.versionedInstructions.map((instruction) => ({\n        programIdIndex: remapIndex(instruction.programIdIndex),\n        accountKeyIndexes: instruction.accountKeyIndexes.map(remapIndex),\n        data: instruction.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\n/**\n * Base builder for Solana v1 (SIMD-0296/0385) transactions.\n *\n * Parallel to the v0 {@link TransactionBuilder}, which is bound to a\n * `@solana/web3.js` v0 `Transaction` and cannot emit a v1 wire. This builder\n * owns the v1 assembly:\n *\n * - intent-to-instruction derivation via the shared `solInstructionFactory`\n *   (same `InstructionParams` representation as the v0 flows)\n * - durable nonce: `AdvanceNonceAccount` instruction injection (first) plus the\n *   nonce hash in the blockhash field\n * - transaction config (compute unit limit, heap size, loaded accounts data\n *   size limit, priority fee as total lamports)\n * - signer management: private-key signers (`sign`) and external signatures\n *   (`addSignature`), assembled in message-signer order\n * - message compile via `compileTransactionMessage` and signed wire via\n *   `serializeWireTransaction`\n *\n * Signature assembly is in message-signer order (fee payer first, then the\n * remaining signers in the compiled account order), NOT insertion order —\n * required for multi-signer v1 transactions such as durable-nonce CT\n * (user + gas-tank nonce authority). Missing signatures are zero-filled in\n * their slots so the wire shape stays valid for partial-sign flows; the\n * broadcastable wire is only produced once every required signer has a\n * signature.\n */\n/**\n * Input shape for {@link V1TransactionBuilder.transactionConfig}: all fields optional;\n * unset values are coerced to null (the SDK v1 serializer contract).\n */\nexport type V1TransactionConfigInput = {\n  computeUnitLimit?: number;\n  heapSize?: number;\n  loadedAccountsDataSizeLimit?: number;\n  priorityFee?: number;\n};\n\nexport abstract class V1TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  private _instructionsData: InstructionParams[] = [];\n  private _extraInstructions: TransactionInstruction[] = [];\n  private _signers: KeyPair[] = [];\n  private _signatures: Map<string, Uint8Array> = new Map();\n  private _lamportsPerSignature: number;\n\n  protected _sender: string;\n  protected _feePayer?: string;\n  protected _recentBlockhash: string;\n  protected _nonceInfo?: Nonce;\n  protected _memo?: string;\n  protected _transactionConfig?: SolV1TransactionConfig;\n  /** Optional override for the zk-elgamal-proof program id (used by CT instruction builders) */\n  protected _zkProofProgramId?: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this.transaction = new Transaction(_coinConfig);\n  }\n\n  /**\n   * The transaction type.\n   */\n  protected abstract get transactionType(): TransactionType;\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    return this.buildV1();\n  }\n\n  /**\n   * Assemble the v1 transaction: derive instructions, inject the durable-nonce\n   * instruction when present, compile the message, and assemble the signed\n   * wire in message-signer order.\n   *\n   * @returns {Transaction} The built transaction holding the v1 message and wire bytes\n   */\n  private buildV1(): Transaction {\n    assert(this._sender, new BuildTransactionError('sender is required before building'));\n    assert(this._recentBlockhash, new BuildTransactionError('recent blockhash is required before building'));\n    assert(this._transactionConfig, 'transactionConfig is required to build a v1 transaction');\n\n    const instructions: TransactionInstruction[] = [];\n\n    // Durable nonce: the AdvanceNonceAccount instruction MUST be part of the\n    // message (a bare nonce hash without the instruction is invalid). It is\n    // placed first, matching the v0 web3.js convention.\n    if (this._nonceInfo) {\n      instructions.push(\n        buildAdvanceNonceAccountInstruction(\n          this._nonceInfo.params.walletNonceAddress,\n          this._nonceInfo.params.authWalletAddress\n        )\n      );\n    }\n\n    for (const instruction of this._instructionsData) {\n      instructions.push(...solInstructionFactory(instruction, this._zkProofProgramId));\n    }\n\n    if (this._memo) {\n      const memoData: Memo = {\n        type: InstructionBuilderTypes.Memo,\n        params: { memo: this._memo },\n      };\n      this._instructionsData.push(memoData);\n      instructions.push(...solInstructionFactory(memoData));\n    }\n\n    instructions.push(...this._extraInstructions);\n\n    const feePayer = this._feePayer ? new PublicKey(this._feePayer) : new PublicKey(this._sender);\n    const messageBytes = compileTransactionMessage({\n      version: 1,\n      instructions,\n      feePayer,\n      recentBlockhash: this._recentBlockhash,\n      transactionConfig: this._transactionConfig,\n    });\n\n    // Signer order comes from the compiled message: the first\n    // numSignerAccounts static accounts are the required signers (fee payer\n    // first, then the remaining signers in the compiled account order).\n    const decoded = decodeV1Message(messageBytes);\n    const signerAddresses = decoded.staticAccounts.slice(0, decoded.header.numSignerAccounts);\n\n    const signatures: Uint8Array[] = [];\n    for (const address of signerAddresses) {\n      const keyPair = this._signers.find((signer) => signer.getKeys().pub === address);\n      if (keyPair) {\n        const secretKey = keyPair.getKeys(true).prv;\n        assert(secretKey instanceof Uint8Array, 'Missing private key');\n        signatures.push(nacl.sign.detached(messageBytes, secretKey));\n        continue;\n      }\n      const external = this._signatures.get(address);\n      if (external) {\n        signatures.push(external);\n        continue;\n      }\n      // Missing signature: zero-fill the slot so the wire shape stays valid\n      // for partial-sign flows; the transaction is not broadcastable until\n      // every required signer has a signature.\n      signatures.push(new Uint8Array(64));\n    }\n\n    const v1Wire = serializeWireTransaction(messageBytes, signatures);\n\n    this._transaction.v1TransactionBytes = v1Wire;\n    this._transaction.v1MessageBytes = messageBytes;\n    this._transaction.lamportsPerSignature = this._lamportsPerSignature;\n\n    // Populate a metadata-only SolTransaction so toJson / loadInputsAndOutputs\n    // work. The durable nonce is carried via nonceInfo, matching the v0 model.\n    const metaTx = new SolTransaction();\n    metaTx.feePayer = feePayer;\n    metaTx.recentBlockhash = this._recentBlockhash;\n    if (this._nonceInfo) {\n      metaTx.nonceInfo = {\n        nonce: this._recentBlockhash,\n        nonceInstruction: buildAdvanceNonceAccountInstruction(\n          this._nonceInfo.params.walletNonceAddress,\n          this._nonceInfo.params.authWalletAddress\n        ),\n      };\n    }\n    metaTx.add(...instructions);\n    this._transaction.solTransaction = metaTx;\n\n    this._transaction.setTransactionType(this.transactionType);\n    this._transaction.setInstructionsData(this._instructionsData);\n    this._transaction.loadInputsAndOutputs();\n\n    return this._transaction;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = new Transaction(this._coinConfig);\n    const wireBytes = new Uint8Array(Buffer.from(rawTransaction, 'base64'));\n    const { messageBytes } = parseWireTransaction(wireBytes);\n    tx.v1TransactionBytes = wireBytes;\n    tx.v1MessageBytes = messageBytes;\n\n    // Populate a metadata-only SolTransaction from the decoded message so\n    // toJson / loadInputsAndOutputs work.\n    const decoded = decodeV1Message(messageBytes);\n    tx.setTransactionType(this.transactionType);\n    const metaTx = new SolTransaction();\n    metaTx.feePayer = new PublicKey(decoded.staticAccounts[0]);\n    metaTx.recentBlockhash = decoded.blockhash;\n    const numWritableSigners = decoded.header.numSignerAccounts - decoded.header.numReadonlySignerAccounts;\n    const numWritableNonSigners = decoded.staticAccounts.length - decoded.header.numReadonlyNonSignerAccounts;\n    for (const compiled of decoded.compiledInstructions) {\n      metaTx.add(\n        new TransactionInstruction({\n          programId: new PublicKey(decoded.staticAccounts[compiled.programAddressIndex]),\n          keys: compiled.accountIndices.map((index) => ({\n            pubkey: new PublicKey(decoded.staticAccounts[index]),\n            isSigner: index < decoded.header.numSignerAccounts,\n            isWritable:\n              index < numWritableSigners ||\n              (index >= decoded.header.numSignerAccounts && index < numWritableNonSigners),\n          })),\n          data: Buffer.from(compiled.data),\n        })\n      );\n    }\n    tx.solTransaction = metaTx;\n\n    return tx;\n  }\n\n  // region Getters and Setters\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  /** @inheritdoc */\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): Transaction {\n    this.validateKey(key);\n    this.checkDuplicatedSigner(key);\n    const prv = key.key;\n    const signer = new KeyPair({ prv: prv });\n    this._signers.push(signer);\n\n    return this._transaction;\n  }\n\n  /** @inheritDoc */\n  addSignature(publicKey: BasePublicKey, signature: Buffer): void {\n    this._signatures.set(publicKey.pub, new Uint8Array(signature));\n  }\n\n  /**\n   * Sets the sender of this transaction.\n   * This account will be responsible for paying transaction fees.\n   *\n   * @param {string} senderAddress the account that is sending this transaction\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  sender(senderAddress: string): this {\n    validateAddress(senderAddress, 'sender');\n    this._sender = senderAddress;\n    return this;\n  }\n\n  /**\n   * Set the transaction nonce.\n   * Requires both optional params in order to use the durable nonce.\n   *\n   * @param {string} blockHash The latest blockHash or the durable nonce hash\n   * @param {DurableNonceParams} [durableNonceParams] An object containing the walletNonceAddress and the authWalletAddress (required for durable nonce)\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  nonce(blockHash: string, durableNonceParams?: { walletNonceAddress: string; authWalletAddress: string }): this {\n    if (!blockHash || !isValidBlockId(blockHash)) {\n      throw new BuildTransactionError('Invalid or missing blockHash, got: ' + blockHash);\n    }\n    if (durableNonceParams) {\n      validateAddress(durableNonceParams.walletNonceAddress, 'walletNonceAddress');\n      validateAddress(durableNonceParams.authWalletAddress, 'authWalletAddress');\n      if (durableNonceParams.walletNonceAddress === durableNonceParams.authWalletAddress) {\n        throw new BuildTransactionError('Invalid params: walletNonceAddress cannot be equal to authWalletAddress');\n      }\n      this._nonceInfo = {\n        type: InstructionBuilderTypes.NonceAdvance,\n        params: durableNonceParams,\n      };\n    }\n    this._recentBlockhash = blockHash;\n    return this;\n  }\n\n  /**\n   * Set the intent instructions to build, using the shared instruction params\n   * representation consumed by `solInstructionFactory` (same as the v0 flows).\n   *\n   * @param {InstructionParams[]} instructions the instruction params\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  instructions(instructions: InstructionParams[]): this {\n    this._instructionsData = [...instructions];\n    return this;\n  }\n\n  /**\n   * Append a pre-built instruction (e.g. an envelope-derived instruction or a\n   * custom instruction) to the transaction.\n   *\n   * @param {TransactionInstruction} instruction the instruction to append\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  addInstruction(instruction: TransactionInstruction): this {\n    this._extraInstructions.push(instruction);\n    return this;\n  }\n\n  /**\n   * Set the v1 transaction config (compute unit limit, heap size, loaded\n   * accounts data size limit, and priority fee as total lamports). Required\n   * before building.\n   *\n   * @param {SolV1TransactionConfig} config the v1 transaction config\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  transactionConfig(config: V1TransactionConfigInput): this {\n    this._transactionConfig = {\n      computeUnitLimit: config.computeUnitLimit ?? null,\n      heapSize: config.heapSize ?? null,\n      loadedAccountsDataSizeLimit: config.loadedAccountsDataSizeLimit ?? null,\n      priorityFee: config.priorityFee ?? null,\n    };\n    return this;\n  }\n\n  /**\n   * Initialize the builder from a client-supplied v1 envelope\n   * (SolVersionedTransactionData). Sets the fee payer from staticAccountKeys[0],\n   * coerces the transaction config, and converts each envelope instruction to an\n   * address-based TransactionInstruction via {@link toV1TransactionInstruction}.\n   *\n   * @param data - the v1 envelope\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  fromVersionedData(data: SolVersionedTransactionData): this {\n    if (!data || typeof data !== 'object') {\n      throw new BuildTransactionError('VersionedTransactionData must be a valid object');\n    }\n    if (!Array.isArray(data.staticAccountKeys) || data.staticAccountKeys.length === 0) {\n      throw new BuildTransactionError('staticAccountKeys must be a non-empty array');\n    }\n    if (!Array.isArray(data.versionedInstructions)) {\n      throw new BuildTransactionError('versionedInstructions must be an array');\n    }\n    if (!data.messageHeader || typeof data.messageHeader !== 'object') {\n      throw new BuildTransactionError('messageHeader must be a valid object');\n    }\n    this._sender = data.staticAccountKeys[0];\n    this._transactionConfig = {\n      computeUnitLimit: data.transactionConfig?.computeUnitLimit ?? null,\n      heapSize: data.transactionConfig?.heapSize ?? null,\n      loadedAccountsDataSizeLimit: data.transactionConfig?.loadedAccountsDataSizeLimit ?? null,\n      priorityFee: data.transactionConfig?.priorityFee ?? null,\n    };\n    for (const instruction of data.versionedInstructions) {\n      this.addInstruction(toV1TransactionInstruction(instruction, data));\n    }\n    return this;\n  }\n\n  /**\n   * Set the priority fee (total lamports) on the v1 transaction config.\n   *\n   * @param {FeeOptions} feeOptions the priority fee\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  setPriorityFee(feeOptions: FeeOptions): this {\n    if (!this._transactionConfig) {\n      this._transactionConfig = {\n        computeUnitLimit: null,\n        heapSize: null,\n        loadedAccountsDataSizeLimit: null,\n        priorityFee: null,\n      };\n    }\n    this._transactionConfig.priorityFee = Number(feeOptions.amount);\n    return this;\n  }\n\n  /**\n   * Set the fee (lamports per signature) for fee estimation.\n   *\n   * @param {FeeOptions} feeOptions the fee\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  fee(feeOptions: FeeOptions): this {\n    this._lamportsPerSignature = Number(feeOptions.amount);\n    return this;\n  }\n\n  feePayer(feePayer: string): this {\n    this._feePayer = feePayer;\n    return this;\n  }\n\n  /**\n   * Set the memo.\n   *\n   * @param {string} memo\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  memo(memo: string): this {\n    this.validateMemo(memo);\n    this._memo = memo;\n    return this;\n  }\n\n  /**\n   * Override the zk-elgamal-proof program id.\n   *\n   * Defaults to the canonical on-chain program id (`ZkE1Gama1Proof111...`)\n   * which is the same across mainnet, devnet, and testnet. Override only\n   * when targeting a custom deployment.\n   *\n   * @param {string} programId base58 encoded program id\n   * @returns {V1TransactionBuilder} This transaction builder\n   */\n  zkProofProgramId(programId: string): this {\n    assert(programId, 'Missing programId param');\n    this._zkProofProgramId = programId;\n    return this;\n  }\n  // endregion\n\n  // region Validators\n  /** @inheritdoc */\n  validateAddress(address: BaseAddress, addressFormat?: string): void {\n    if (!isValidAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address ' + address.address);\n    }\n  }\n\n  /** @inheritdoc */\n  validateKey(key: BaseKey): void {\n    let keyPair: KeyPair;\n    try {\n      keyPair = new KeyPair({ prv: key.key });\n    } catch {\n      throw new BuildTransactionError('Invalid key');\n    }\n\n    if (!keyPair.getKeys().prv) {\n      throw new BuildTransactionError('Invalid key');\n    }\n  }\n\n  /** @inheritdoc */\n  validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new BuildTransactionError('Invalid raw transaction');\n    }\n    try {\n      parseWireTransaction(new Uint8Array(Buffer.from(rawTransaction, 'base64')));\n    } catch (e) {\n      throw new BuildTransactionError('Invalid raw transaction: ' + (e as Error).message);\n    }\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: Transaction): void {\n    this.validateSender();\n    this.validateNonce();\n  }\n\n  /** @inheritdoc */\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new BuildTransactionError('Value cannot be less than zero');\n    }\n  }\n\n  /**\n   * Validates the memo.\n   *\n   * @param {string} memo - the memo as string\n   */\n  validateMemo(memo: string): void {\n    if (!memo) {\n      throw new BuildTransactionError('Invalid memo, got: ' + memo);\n    }\n    if (!isValidMemo(memo)) {\n      throw new BuildTransactionError('Memo is too long');\n    }\n  }\n\n  /**\n   * Validates that the given key is not already in this._signers.\n   *\n   * @param {BaseKey} key - The key to check\n   */\n  private checkDuplicatedSigner(key: BaseKey) {\n    this._signers.forEach((kp) => {\n      if (kp.getKeys().prv === key.key) {\n        throw new SigningError('Duplicated signer: ' + key.key);\n      }\n    });\n  }\n\n  /**\n   * Validates that the sender field is defined.\n   */\n  private validateSender(): void {\n    if (this._sender === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing sender');\n    }\n  }\n\n  /**\n   * Validates that the nonce field is defined.\n   */\n  private validateNonce(): void {\n    if (this._recentBlockhash === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing nonce blockhash');\n    }\n  }\n  // endregion\n}\n"]}