@bitgo-beta/sdk-coin-sol 7.6.4-beta.73 → 7.6.4-beta.731

package/dist/esm/lib/transactionBuilder.js

@@ -0,0 +1,455 @@
+import { BaseTransactionBuilder, BuildTransactionError, SigningError, } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { MessageV0, PublicKey, Transaction as SolTransaction, VersionedTransaction, } from '@solana/web3.js';
+import base58 from 'bs58';
+import { isValidAddress, isValidAmount, isValidBlockId, isValidMemo, validateAddress, validateRawTransaction, } from './utils';
+import { KeyPair } from '.';
+import { InstructionBuilderTypes, MAX_COMPUTE_UNIT_LIMIT } from './constants';
+import { solInstructionFactory } from './solInstructionFactory';
+import assert from 'assert';
+import { instructionParamsFactory } from './instructionParamsFactory';
+export class TransactionBuilder extends BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._signatures = [];
+        this._instructionsData = [];
+        this._signers = [];
+        this.transaction = new Transaction(_coinConfig);
+    }
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     */
+    initBuilder(tx) {
+        this._transaction = tx;
+        const txData = tx.toJson();
+        const filteredTransferInstructionsData = txData.instructionsData.filter((data) => data.type === InstructionBuilderTypes.Transfer);
+        let sender;
+        if (filteredTransferInstructionsData.length > 0) {
+            const transferInstructionsData = filteredTransferInstructionsData[0];
+            sender = transferInstructionsData.params.fromAddress;
+        }
+        else {
+            sender = txData.feePayer;
+        }
+        this.sender(sender);
+        this.feePayer(txData.feePayer);
+        this.nonce(txData.nonce, txData.durableNonce);
+        this._instructionsData = instructionParamsFactory(tx.type, tx.solTransaction.instructions, this._coinConfig.name, txData.instructionsData, tx.useTokenAddressTokenName);
+        // Parse priority fee instruction data
+        const filteredPriorityFeeInstructionsData = txData.instructionsData.filter((data) => data.type === InstructionBuilderTypes.SetPriorityFee);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.Memo) {
+                const memoInstruction = instruction;
+                this.memo(memoInstruction.params.memo);
+            }
+            if (instruction.type === InstructionBuilderTypes.NonceAdvance) {
+                const advanceNonceInstruction = instruction;
+                this.nonce(txData.nonce, advanceNonceInstruction.params);
+            }
+            // If prio fee instruction exists, set the priority fee variable
+            if (instruction.type === InstructionBuilderTypes.SetPriorityFee) {
+                const priorityFeeInstructionsData = filteredPriorityFeeInstructionsData[0];
+                this.setPriorityFee({ amount: Number(priorityFeeInstructionsData.params.fee) });
+            }
+            // If compute unit limit instruction exists, restore the compute unit limit
+            if (instruction.type === InstructionBuilderTypes.SetComputeUnitLimit) {
+                const computeUnitLimitInstruction = instruction;
+                this.setComputeUnitLimit(computeUnitLimitInstruction.params.units);
+            }
+        }
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = new Transaction(this._coinConfig);
+        this.validateRawTransaction(rawTransaction);
+        tx.fromRawTransaction(rawTransaction);
+        this.initBuilder(tx);
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        const builtTransaction = this.buildSolTransaction();
+        if (builtTransaction instanceof VersionedTransaction) {
+            this.transaction.versionedTransaction = builtTransaction;
+        }
+        else {
+            this.transaction.solTransaction = builtTransaction;
+        }
+        this.transaction.setTransactionType(this.transactionType);
+        this.transaction.setInstructionsData(this._instructionsData);
+        this.transaction.loadInputsAndOutputs();
+        this._transaction.tokenAccountRentExemptAmount = this._tokenAccountRentExemptAmount;
+        return this.transaction;
+    }
+    /**
+     * Builds the solana transaction.
+     */
+    buildSolTransaction() {
+        assert(this._sender, new BuildTransactionError('sender is required before building'));
+        assert(this._recentBlockhash, new BuildTransactionError('recent blockhash is required before building'));
+        // Check if we should build as VersionedTransaction
+        if (this._transaction.isVersionedTransaction()) {
+            return this.buildVersionedTransaction();
+        }
+        else {
+            return this.buildLegacyTransaction();
+        }
+    }
+    /**
+     * Builds a legacy Solana transaction.
+     */
+    buildLegacyTransaction() {
+        const tx = new SolTransaction();
+        if (this._transaction?.solTransaction?.signatures) {
+            tx.signatures = this._transaction?.solTransaction?.signatures;
+        }
+        tx.feePayer = this._feePayer ? new PublicKey(this._feePayer) : new PublicKey(this._sender);
+        if (this._nonceInfo) {
+            tx.nonceInfo = {
+                nonce: this._recentBlockhash,
+                nonceInstruction: solInstructionFactory(this._nonceInfo)[0],
+            };
+        }
+        else {
+            tx.recentBlockhash = this._recentBlockhash;
+        }
+        // The priority fee is charged on the requested compute-unit limit, so an explicit
+        // limit must precede every entry of _instructionsData (including the optional
+        // SetComputeUnitPrice). web3.js serializes the durable-nonce AdvanceNonceAccount
+        // first via nonceInfo, giving [AdvanceNonce, SetComputeUnitLimit, SetComputeUnitPrice?, ...].
+        const computeUnitLimitData = this._computeUnitLimit !== undefined
+            ? {
+                type: InstructionBuilderTypes.SetComputeUnitLimit,
+                params: {
+                    units: this._computeUnitLimit,
+                },
+            }
+            : undefined;
+        if (computeUnitLimitData) {
+            tx.add(...solInstructionFactory(computeUnitLimitData));
+        }
+        for (const instruction of this._instructionsData) {
+            tx.add(...solInstructionFactory(instruction, this._zkProofProgramId));
+        }
+        if (computeUnitLimitData) {
+            // Record the instruction so explain and parsing see it, mirroring how memo is recorded
+            this._instructionsData.unshift(computeUnitLimitData);
+        }
+        if (this._memo) {
+            const memoData = {
+                type: InstructionBuilderTypes.Memo,
+                params: {
+                    memo: this._memo,
+                },
+            };
+            this._instructionsData.push(memoData);
+            tx.add(...solInstructionFactory(memoData));
+        }
+        this._transaction.lamportsPerSignature = this._lamportsPerSignature;
+        for (const signer of this._signers) {
+            const publicKey = new PublicKey(signer.getKeys().pub);
+            const secretKey = signer.getKeys(true).prv;
+            assert(secretKey instanceof Uint8Array);
+            tx.partialSign({ publicKey, secretKey });
+        }
+        for (const signature of this._signatures) {
+            const solPublicKey = new PublicKey(signature.publicKey.pub);
+            tx.addSignature(solPublicKey, signature.signature);
+        }
+        return tx;
+    }
+    /**
+     * Builds a VersionedTransaction.
+     *
+     * @returns {VersionedTransaction} The built versioned transaction
+     */
+    buildVersionedTransaction() {
+        const versionedTxData = this._transaction.getVersionedTransactionData();
+        if (!versionedTxData) {
+            throw new BuildTransactionError('Missing VersionedTransactionData');
+        }
+        const versionedTx = this.buildFromVersionedData(versionedTxData);
+        this._transaction.lamportsPerSignature = this._lamportsPerSignature;
+        for (const signer of this._signers) {
+            const publicKey = new PublicKey(signer.getKeys().pub);
+            const secretKey = signer.getKeys(true).prv;
+            assert(secretKey instanceof Uint8Array);
+            versionedTx.sign([{ publicKey, secretKey }]);
+        }
+        for (const signature of this._signatures) {
+            const solPublicKey = new PublicKey(signature.publicKey.pub);
+            versionedTx.addSignature(solPublicKey, signature.signature);
+        }
+        return versionedTx;
+    }
+    /**
+     * Build a VersionedTransaction from deconstructed VersionedTransactionData
+     * @param data The versioned transaction data
+     * @returns The built versioned transaction
+     */
+    buildFromVersionedData(data) {
+        const staticAccountKeys = data.staticAccountKeys.map((key) => new PublicKey(key));
+        const addressTableLookups = data.addressLookupTables.map((alt) => ({
+            accountKey: new PublicKey(alt.accountKey),
+            writableIndexes: alt.writableIndexes,
+            readonlyIndexes: alt.readonlyIndexes,
+        }));
+        const compiledInstructions = data.versionedInstructions.map((instruction) => ({
+            programIdIndex: instruction.programIdIndex,
+            accountKeyIndexes: instruction.accountKeyIndexes,
+            data: Buffer.from(base58.decode(instruction.data)),
+        }));
+        const recentBlockhash = data.recentBlockhash || this._recentBlockhash;
+        if (!recentBlockhash) {
+            throw new BuildTransactionError('Missing recent blockhash for VersionedTransaction');
+        }
+        if (!this._sender) {
+            throw new BuildTransactionError('Missing sender (fee payer) for VersionedTransaction');
+        }
+        const messageV0 = new MessageV0({
+            header: data.messageHeader,
+            staticAccountKeys,
+            recentBlockhash: recentBlockhash,
+            compiledInstructions,
+            addressTableLookups,
+        });
+        return new VersionedTransaction(messageV0);
+    }
+    // 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.push({ publicKey, signature });
+    }
+    /**
+     * Get the externally-added signatures (via addSignature) in order.
+     *
+     * @returns {Signature[]} The list of external signatures
+     */
+    getAdditionalSignatures() {
+        return this._signatures;
+    }
+    /**
+     * Add a signature produced by the fee payer of the transaction being built.
+     * The fee payer is account 0 of the transaction message, so its signature belongs in slot 0.
+     * Use this for signatures produced by the enterprise fee address key (HSM single-sig) of a
+     * sponsored transaction; the key must match account 0.
+     *
+     * @param {BasePublicKey} publicKey The public key of the fee payer; must be account 0 of the message
+     * @param {Buffer} signature The signature of the transaction payload
+     */
+    addFeePayerSignature(publicKey, signature) {
+        if (publicKey.pub !== this.getFeePayerAccountKey()) {
+            throw new SigningError(`Fee payer signature must come from account 0 of the message, got: ${publicKey.pub}`);
+        }
+        this.addSignature(publicKey, signature);
+    }
+    /**
+     * The account 0 key of the message being built, i.e. the fee payer: the first static account
+     * key of a versioned transaction, or the fee payer of a legacy transaction.
+     */
+    getFeePayerAccountKey() {
+        const versionedData = this._transaction.getVersionedTransactionData();
+        if (versionedData) {
+            return versionedData.staticAccountKeys[0];
+        }
+        return this._feePayer ?? this._sender;
+    }
+    /**
+     * 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 {TransactionBuilder} 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 {Blockhash} blockHash The latest blockHash
+     * @param {DurableNonceParams} [durableNonceParams] An object containing the walletNonceAddress and the authWalletAddress (required for durable nonce)
+     * @returns {TransactionBuilder} 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 memo
+     *
+     * @param {string} memo
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    memo(memo) {
+        this.validateMemo(memo);
+        this._memo = memo;
+        return this;
+    }
+    fee(feeOptions) {
+        this._lamportsPerSignature = Number(feeOptions.amount);
+        return this;
+    }
+    setPriorityFee(feeOptions) {
+        this._priorityFee = Number(feeOptions.amount);
+        return this;
+    }
+    /**
+     * Set an explicit compute-unit limit for this transaction.
+     *
+     * The priority fee is charged on the requested compute-unit limit rather than the
+     * units actually consumed, so every sponsored transaction must set an intent-sized
+     * limit. When set, the built transaction prepends a SetComputeUnitLimit instruction
+     * ahead of all other instructions (after the durable-nonce AdvanceNonceAccount):
+     * [AdvanceNonce?, SetComputeUnitLimit, SetComputeUnitPrice?, ...]. When unset, the
+     * built transaction bytes are unchanged.
+     *
+     * @param {number} units the requested compute-unit limit, an integer between
+     * 1 and 1,400,000 (the on-chain per-transaction maximum)
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    setComputeUnitLimit(units) {
+        this.validateComputeUnitLimit(units);
+        this._computeUnitLimit = units;
+        return this;
+    }
+    validateComputeUnitLimit(units) {
+        if (!Number.isInteger(units) || units < 1 || units > MAX_COMPUTE_UNIT_LIMIT) {
+            throw new BuildTransactionError(`Invalid compute unit limit, expected an integer between 1 and ${MAX_COMPUTE_UNIT_LIMIT}, got: ${units}`);
+        }
+    }
+    feePayer(feePayer) {
+        this._feePayer = feePayer;
+        return this;
+    }
+    /**
+     * Used to set the minimum rent exempt amount for an ATA
+     *
+     * @param tokenAccountRentExemptAmount minimum rent exempt amount in lamports
+     */
+    associatedTokenAccountRent(tokenAccountRentExemptAmount) {
+        this.validateRentExemptAmount(tokenAccountRentExemptAmount);
+        this._tokenAccountRentExemptAmount = tokenAccountRentExemptAmount;
+        return this;
+    }
+    validateRentExemptAmount(tokenAccountRentExemptAmount) {
+        // _tokenAccountRentExemptAmount is allowed to be undefined or a valid amount if it's defined
+        if (tokenAccountRentExemptAmount && !isValidAmount(tokenAccountRentExemptAmount)) {
+            throw new BuildTransactionError('Invalid tokenAccountRentExemptAmount, got: ' + tokenAccountRentExemptAmount);
+        }
+    }
+    // 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) {
+        validateRawTransaction(rawTransaction);
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        this.validateSender();
+        this.validateNonce();
+        this.validateRentExemptAmount(this._tokenAccountRentExemptAmount);
+    }
+    /** @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":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.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  Signature,\n  SigningError,\n  SolVersionedTransactionData,\n  TransactionType,\n} from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport {\n  Blockhash,\n  MessageAddressTableLookup,\n  MessageV0,\n  PublicKey,\n  Transaction as SolTransaction,\n  VersionedTransaction,\n} from '@solana/web3.js';\nimport base58 from 'bs58';\nimport {\n  isValidAddress,\n  isValidAmount,\n  isValidBlockId,\n  isValidMemo,\n  validateAddress,\n  validateRawTransaction,\n} from './utils';\nimport { KeyPair } from '.';\nimport { InstructionBuilderTypes, MAX_COMPUTE_UNIT_LIMIT } from './constants';\nimport { solInstructionFactory } from './solInstructionFactory';\nimport assert from 'assert';\nimport {\n  DurableNonceParams,\n  InstructionParams,\n  Memo,\n  Nonce,\n  SetComputeUnitLimit,\n  SetPriorityFee,\n  Transfer,\n} from './iface';\nimport { instructionParamsFactory } from './instructionParamsFactory';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  private _signatures: Signature[] = [];\n  private _lamportsPerSignature: number;\n  private _tokenAccountRentExemptAmount: string;\n\n  protected _sender: string;\n  protected _recentBlockhash: Blockhash;\n  protected _nonceInfo: Nonce;\n  protected _instructionsData: InstructionParams[] = [];\n  protected _signers: KeyPair[] = [];\n  protected _memo?: string;\n  protected _feePayer?: string;\n  protected _priorityFee: number;\n  /** Explicit compute-unit limit requested for the transaction, in compute units */\n  protected _computeUnitLimit?: number;\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  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx the transaction data\n   */\n  initBuilder(tx: Transaction): void {\n    this._transaction = tx;\n    const txData = tx.toJson();\n\n    const filteredTransferInstructionsData = txData.instructionsData.filter(\n      (data) => data.type === InstructionBuilderTypes.Transfer\n    );\n    let sender;\n    if (filteredTransferInstructionsData.length > 0) {\n      const transferInstructionsData = filteredTransferInstructionsData[0] as Transfer;\n      sender = transferInstructionsData.params.fromAddress;\n    } else {\n      sender = txData.feePayer;\n    }\n    this.sender(sender);\n    this.feePayer(txData.feePayer as string);\n    this.nonce(txData.nonce, txData.durableNonce);\n    this._instructionsData = instructionParamsFactory(\n      tx.type,\n      tx.solTransaction.instructions,\n      this._coinConfig.name,\n      txData.instructionsData,\n      tx.useTokenAddressTokenName\n    );\n    // Parse priority fee instruction data\n    const filteredPriorityFeeInstructionsData = txData.instructionsData.filter(\n      (data) => data.type === InstructionBuilderTypes.SetPriorityFee\n    );\n\n    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.Memo) {\n        const memoInstruction: Memo = instruction;\n        this.memo(memoInstruction.params.memo);\n      }\n\n      if (instruction.type === InstructionBuilderTypes.NonceAdvance) {\n        const advanceNonceInstruction: Nonce = instruction;\n        this.nonce(txData.nonce, advanceNonceInstruction.params);\n      }\n\n      // If prio fee instruction exists, set the priority fee variable\n      if (instruction.type === InstructionBuilderTypes.SetPriorityFee) {\n        const priorityFeeInstructionsData = filteredPriorityFeeInstructionsData[0] as SetPriorityFee;\n        this.setPriorityFee({ amount: Number(priorityFeeInstructionsData.params.fee) });\n      }\n\n      // If compute unit limit instruction exists, restore the compute unit limit\n      if (instruction.type === InstructionBuilderTypes.SetComputeUnitLimit) {\n        const computeUnitLimitInstruction = instruction as SetComputeUnitLimit;\n        this.setComputeUnitLimit(computeUnitLimitInstruction.params.units);\n      }\n    }\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = new Transaction(this._coinConfig);\n    this.validateRawTransaction(rawTransaction);\n    tx.fromRawTransaction(rawTransaction);\n    this.initBuilder(tx);\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    const builtTransaction = this.buildSolTransaction();\n\n    if (builtTransaction instanceof VersionedTransaction) {\n      this.transaction.versionedTransaction = builtTransaction;\n    } else {\n      this.transaction.solTransaction = builtTransaction;\n    }\n\n    this.transaction.setTransactionType(this.transactionType);\n    this.transaction.setInstructionsData(this._instructionsData);\n    this.transaction.loadInputsAndOutputs();\n    this._transaction.tokenAccountRentExemptAmount = this._tokenAccountRentExemptAmount;\n    return this.transaction;\n  }\n\n  /**\n   * Builds the solana transaction.\n   */\n  protected buildSolTransaction(): SolTransaction | VersionedTransaction {\n    assert(this._sender, new BuildTransactionError('sender is required before building'));\n    assert(this._recentBlockhash, new BuildTransactionError('recent blockhash is required before building'));\n\n    // Check if we should build as VersionedTransaction\n    if (this._transaction.isVersionedTransaction()) {\n      return this.buildVersionedTransaction();\n    } else {\n      return this.buildLegacyTransaction();\n    }\n  }\n\n  /**\n   * Builds a legacy Solana transaction.\n   */\n  private buildLegacyTransaction(): SolTransaction {\n    const tx = new SolTransaction();\n    if (this._transaction?.solTransaction?.signatures) {\n      tx.signatures = this._transaction?.solTransaction?.signatures;\n    }\n\n    tx.feePayer = this._feePayer ? new PublicKey(this._feePayer) : new PublicKey(this._sender);\n\n    if (this._nonceInfo) {\n      tx.nonceInfo = {\n        nonce: this._recentBlockhash,\n        nonceInstruction: solInstructionFactory(this._nonceInfo)[0],\n      };\n    } else {\n      tx.recentBlockhash = this._recentBlockhash;\n    }\n\n    // The priority fee is charged on the requested compute-unit limit, so an explicit\n    // limit must precede every entry of _instructionsData (including the optional\n    // SetComputeUnitPrice). web3.js serializes the durable-nonce AdvanceNonceAccount\n    // first via nonceInfo, giving [AdvanceNonce, SetComputeUnitLimit, SetComputeUnitPrice?, ...].\n    const computeUnitLimitData: SetComputeUnitLimit | undefined =\n      this._computeUnitLimit !== undefined\n        ? {\n            type: InstructionBuilderTypes.SetComputeUnitLimit,\n            params: {\n              units: this._computeUnitLimit,\n            },\n          }\n        : undefined;\n    if (computeUnitLimitData) {\n      tx.add(...solInstructionFactory(computeUnitLimitData));\n    }\n    for (const instruction of this._instructionsData) {\n      tx.add(...solInstructionFactory(instruction, this._zkProofProgramId));\n    }\n    if (computeUnitLimitData) {\n      // Record the instruction so explain and parsing see it, mirroring how memo is recorded\n      this._instructionsData.unshift(computeUnitLimitData);\n    }\n\n    if (this._memo) {\n      const memoData: Memo = {\n        type: InstructionBuilderTypes.Memo,\n        params: {\n          memo: this._memo,\n        },\n      };\n      this._instructionsData.push(memoData);\n      tx.add(...solInstructionFactory(memoData));\n    }\n\n    this._transaction.lamportsPerSignature = this._lamportsPerSignature;\n\n    for (const signer of this._signers) {\n      const publicKey = new PublicKey(signer.getKeys().pub);\n      const secretKey = signer.getKeys(true).prv;\n      assert(secretKey instanceof Uint8Array);\n      tx.partialSign({ publicKey, secretKey });\n    }\n\n    for (const signature of this._signatures) {\n      const solPublicKey = new PublicKey(signature.publicKey.pub);\n      tx.addSignature(solPublicKey, signature.signature);\n    }\n\n    return tx;\n  }\n\n  /**\n   * Builds a VersionedTransaction.\n   *\n   * @returns {VersionedTransaction} The built versioned transaction\n   */\n  private buildVersionedTransaction(): VersionedTransaction {\n    const versionedTxData = this._transaction.getVersionedTransactionData();\n\n    if (!versionedTxData) {\n      throw new BuildTransactionError('Missing VersionedTransactionData');\n    }\n\n    const versionedTx = this.buildFromVersionedData(versionedTxData);\n\n    this._transaction.lamportsPerSignature = this._lamportsPerSignature;\n\n    for (const signer of this._signers) {\n      const publicKey = new PublicKey(signer.getKeys().pub);\n      const secretKey = signer.getKeys(true).prv;\n      assert(secretKey instanceof Uint8Array);\n      versionedTx.sign([{ publicKey, secretKey }]);\n    }\n\n    for (const signature of this._signatures) {\n      const solPublicKey = new PublicKey(signature.publicKey.pub);\n      versionedTx.addSignature(solPublicKey, signature.signature);\n    }\n\n    return versionedTx;\n  }\n\n  /**\n   * Build a VersionedTransaction from deconstructed VersionedTransactionData\n   * @param data The versioned transaction data\n   * @returns The built versioned transaction\n   */\n  private buildFromVersionedData(data: SolVersionedTransactionData): VersionedTransaction {\n    const staticAccountKeys = data.staticAccountKeys.map((key: string) => new PublicKey(key));\n\n    const addressTableLookups: MessageAddressTableLookup[] = data.addressLookupTables.map((alt) => ({\n      accountKey: new PublicKey(alt.accountKey),\n      writableIndexes: alt.writableIndexes,\n      readonlyIndexes: alt.readonlyIndexes,\n    }));\n\n    const compiledInstructions = data.versionedInstructions.map((instruction) => ({\n      programIdIndex: instruction.programIdIndex,\n      accountKeyIndexes: instruction.accountKeyIndexes,\n      data: Buffer.from(base58.decode(instruction.data)),\n    }));\n\n    const recentBlockhash = data.recentBlockhash || this._recentBlockhash;\n\n    if (!recentBlockhash) {\n      throw new BuildTransactionError('Missing recent blockhash for VersionedTransaction');\n    }\n\n    if (!this._sender) {\n      throw new BuildTransactionError('Missing sender (fee payer) for VersionedTransaction');\n    }\n\n    const messageV0 = new MessageV0({\n      header: data.messageHeader,\n      staticAccountKeys,\n      recentBlockhash: recentBlockhash,\n      compiledInstructions,\n      addressTableLookups,\n    });\n\n    return new VersionedTransaction(messageV0);\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.push({ publicKey, signature });\n  }\n\n  /**\n   * Get the externally-added signatures (via addSignature) in order.\n   *\n   * @returns {Signature[]} The list of external signatures\n   */\n  protected getAdditionalSignatures(): Signature[] {\n    return this._signatures;\n  }\n\n  /**\n   * Add a signature produced by the fee payer of the transaction being built.\n   * The fee payer is account 0 of the transaction message, so its signature belongs in slot 0.\n   * Use this for signatures produced by the enterprise fee address key (HSM single-sig) of a\n   * sponsored transaction; the key must match account 0.\n   *\n   * @param {BasePublicKey} publicKey The public key of the fee payer; must be account 0 of the message\n   * @param {Buffer} signature The signature of the transaction payload\n   */\n  addFeePayerSignature(publicKey: BasePublicKey, signature: Buffer): void {\n    if (publicKey.pub !== this.getFeePayerAccountKey()) {\n      throw new SigningError(`Fee payer signature must come from account 0 of the message, got: ${publicKey.pub}`);\n    }\n    this.addSignature(publicKey, signature);\n  }\n\n  /**\n   * The account 0 key of the message being built, i.e. the fee payer: the first static account\n   * key of a versioned transaction, or the fee payer of a legacy transaction.\n   */\n  private getFeePayerAccountKey(): string | undefined {\n    const versionedData = this._transaction.getVersionedTransactionData();\n    if (versionedData) {\n      return versionedData.staticAccountKeys[0];\n    }\n    return this._feePayer ?? this._sender;\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 {TransactionBuilder} 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 {Blockhash} blockHash The latest blockHash\n   * @param {DurableNonceParams} [durableNonceParams] An object containing the walletNonceAddress and the authWalletAddress (required for durable nonce)\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  nonce(blockHash: Blockhash, durableNonceParams?: DurableNonceParams): 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 memo\n   *\n   * @param {string} memo\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  memo(memo: string): this {\n    this.validateMemo(memo);\n    this._memo = memo;\n    return this;\n  }\n\n  fee(feeOptions: FeeOptions): this {\n    this._lamportsPerSignature = Number(feeOptions.amount);\n    return this;\n  }\n\n  public setPriorityFee(feeOptions: FeeOptions): this {\n    this._priorityFee = Number(feeOptions.amount);\n    return this;\n  }\n\n  /**\n   * Set an explicit compute-unit limit for this transaction.\n   *\n   * The priority fee is charged on the requested compute-unit limit rather than the\n   * units actually consumed, so every sponsored transaction must set an intent-sized\n   * limit. When set, the built transaction prepends a SetComputeUnitLimit instruction\n   * ahead of all other instructions (after the durable-nonce AdvanceNonceAccount):\n   * [AdvanceNonce?, SetComputeUnitLimit, SetComputeUnitPrice?, ...]. When unset, the\n   * built transaction bytes are unchanged.\n   *\n   * @param {number} units the requested compute-unit limit, an integer between\n   * 1 and 1,400,000 (the on-chain per-transaction maximum)\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  public setComputeUnitLimit(units: number): this {\n    this.validateComputeUnitLimit(units);\n    this._computeUnitLimit = units;\n    return this;\n  }\n\n  private validateComputeUnitLimit(units: number): void {\n    if (!Number.isInteger(units) || units < 1 || units > MAX_COMPUTE_UNIT_LIMIT) {\n      throw new BuildTransactionError(\n        `Invalid compute unit limit, expected an integer between 1 and ${MAX_COMPUTE_UNIT_LIMIT}, got: ${units}`\n      );\n    }\n  }\n\n  feePayer(feePayer: string): this {\n    this._feePayer = feePayer;\n    return this;\n  }\n\n  /**\n   * Used to set the minimum rent exempt amount for an ATA\n   *\n   * @param tokenAccountRentExemptAmount minimum rent exempt amount in lamports\n   */\n  associatedTokenAccountRent(tokenAccountRentExemptAmount: string): this {\n    this.validateRentExemptAmount(tokenAccountRentExemptAmount);\n    this._tokenAccountRentExemptAmount = tokenAccountRentExemptAmount;\n    return this;\n  }\n\n  private validateRentExemptAmount(tokenAccountRentExemptAmount: string) {\n    // _tokenAccountRentExemptAmount is allowed to be undefined or a valid amount if it's defined\n    if (tokenAccountRentExemptAmount && !isValidAmount(tokenAccountRentExemptAmount)) {\n      throw new BuildTransactionError('Invalid tokenAccountRentExemptAmount, got: ' + tokenAccountRentExemptAmount);\n    }\n  }\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    validateRawTransaction(rawTransaction);\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: Transaction): void {\n    this.validateSender();\n    this.validateNonce();\n    this.validateRentExemptAmount(this._tokenAccountRentExemptAmount);\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  /** 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"]}