@bitgo-beta/sdk-coin-sol 7.6.4-beta.76 → 7.6.4-beta.761

package/dist/cjs/src/lib/confidentialTransferBuilder.d.ts

@@ -0,0 +1,136 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { SolTransactionVersion, SolV1TransactionConfig, TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { ApplyPendingBalance, AtaInit, ConfidentialDeposit, ConfidentialTransfer, ConfidentialWithdraw, ConfigureConfidentialTransferAccount, VerifyEqualityProof, VerifyPubkeyValidity, VerifyRangeProof, VerifyValidityProof } from './iface';
+/**
+ * Builder for Token-2022 confidential transfer transactions.
+ *
+ * Provides type-safe fluent setters for the following CT instructions:
+ * - CreateAssociatedTokenAccount (CT enablement: ATA under Token-2022 before ConfigureAccount)
+ * - ConfigureAccount (standalone, with VerifyPubkeyValidity proof)
+ * - ApplyPendingBalance (always instruction #1 in v1 spend txs, idempotent)
+ * - Deposit (public → confidential conversion)
+ * - Withdraw (confidential → public conversion, with equality + range proofs)
+ * - Transfer (confidential → confidential, with equality + validity + range proofs)
+ * - VerifyPubkeyValidity / VerifyEquality / VerifyValidity / VerifyRange proof instructions
+ *
+ * Instruction builders are v0/v1-agnostic: they produce instruction data and
+ * account metas only. The caller (Wallet Platform) assembles them into v1
+ * transactions in the correct order.
+ *
+ * @example
+ * ```ts
+ * const builder = factory.getConfidentialTransferBuilder();
+ * builder.nonce(recentBlockhash).sender(payer);
+ * builder.configureAccount({ tokenAddress, mintAddress, authorityAddress, ... });
+ * builder.verifyPubkeyValidity({ proofData });
+ * const tx = await builder.build();
+ * ```
+ */
+export declare class ConfidentialTransferBuilder extends TransactionBuilder {
+    private _ctInstructions;
+    private _version?;
+    private _v1TransactionConfig?;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /**
+     * Set the Solana transaction version.
+     *
+     * Defaults to legacy until set. When set to `1`, the builder assembles a v1
+     * (SIMD-0296/0385) transaction: version byte `0x81`, an inline `transactionConfig`
+     * instead of ComputeBudget instructions, no address lookup tables, and a
+     * message-first wire format with signatures appended.
+     *
+     * @param version - the transaction version (0 = v0, 1 = v1)
+     * @returns {this} This builder
+     */
+    version(version: SolTransactionVersion): this;
+    /**
+     * Set the v1 transaction config (compute unit limit, heap size, loaded accounts
+     * data size limit, and priority fee as total lamports). Required when
+     * `version(1)` is set.
+     *
+     * @param config - the v1 transaction config
+     * @returns {this} This builder
+     */
+    transactionConfig(config: SolV1TransactionConfig): 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 programId - base58 encoded program id
+     */
+    zkProofProgramId(programId: string): this;
+    /** @inheritDoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * Add a CreateAssociatedTokenAccount (idempotent) instruction to the transaction.
+     * CT enablement only — the ATA must exist before ConfigureAccount; add this
+     * first when the ATA is not yet on-chain. For Token-2022 mints pass
+     * `programId` so the ATA is created under the Token-2022 program.
+     */
+    createAta(params: AtaInit['params']): this;
+    /**
+     * Add a ConfigureAccount instruction to the transaction.
+     * One-time ATA setup — registers ElGamal pubkey + AES zero ciphertext.
+     * Must be accompanied by a VerifyPubkeyValidity proof instruction.
+     */
+    configureAccount(params: ConfigureConfidentialTransferAccount['params']): this;
+    /**
+     * Add an ApplyPendingBalance instruction to the transaction.
+     * Credits pending balance into available balance. Idempotent (no-op if 0 pending).
+     * In v1 transactions, this should always be instruction #1.
+     */
+    applyPendingBalance(params: ApplyPendingBalance['params']): this;
+    /**
+     * Add a Deposit instruction to the transaction.
+     * Moves public SPL tokens into confidential pending balance. No proof required.
+     */
+    confidentialDeposit(params: ConfidentialDeposit['params']): this;
+    /**
+     * Add a Withdraw instruction to the transaction.
+     * Moves confidential available balance to public balance.
+     * Requires equality + range proof verification instructions.
+     */
+    confidentialWithdraw(params: ConfidentialWithdraw['params']): this;
+    /**
+     * Add a confidential Transfer instruction to the transaction.
+     * Requires equality + ciphertext validity + range proof verification instructions.
+     */
+    confidentialTransfer(params: ConfidentialTransfer['params']): this;
+    /**
+     * Add a VerifyPubkeyValidity proof instruction (used with ConfigureAccount).
+     */
+    verifyPubkeyValidity(params: VerifyPubkeyValidity['params']): this;
+    /**
+     * Add a VerifyCiphertextCommitmentEquality proof instruction (used with Transfer and Withdraw).
+     */
+    verifyEqualityProof(params: VerifyEqualityProof['params']): this;
+    /**
+     * Add a VerifyBatchedGroupedCiphertext3HandlesValidity proof instruction (used with Transfer).
+     */
+    verifyValidityProof(params: VerifyValidityProof['params']): this;
+    /**
+     * Add a VerifyBatchedRangeProofU128 proof instruction (used with Transfer).
+     */
+    verifyRangeProof(params: VerifyRangeProof['params']): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Build a v1 (SIMD-0296/0385) confidential transfer transaction.
+     *
+     * Assembles the CT instructions via the shared instruction factory, compiles
+     * and serializes a v1 message with the inline transaction config, signs the
+     * message bytes with the builder's signers, and stores the resulting wire
+     * bytes for broadcast. Also populates a metadata-only SolTransaction so the
+     * transaction JSON and input/output extraction remain usable.
+     *
+     * @returns {Transaction} The built transaction holding the v1 wire bytes
+     */
+    private buildV1;
+}
+//# sourceMappingURL=confidentialTransferBuilder.d.ts.map

package/dist/cjs/src/lib/confidentialTransferBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidentialTransferBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/confidentialTransferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,qBAAqB,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG7H,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EACL,mBAAmB,EACnB,OAAO,EACP,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,oCAAoC,EAGpC,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAQjB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,2BAA4B,SAAQ,kBAAkB;IACjE,OAAO,CAAC,eAAe,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,CAAwB;IACzC,OAAO,CAAC,oBAAoB,CAAC,CAAyB;gBAE1C,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;;;;;;OAUG;IACH,OAAO,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAK7C;;;;;;;OAOG;IACH,iBAAiB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAKvD;;;;;;;;OAQG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAMzC,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAwBlC;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI;IAwB1C;;;;OAIG;IACH,gBAAgB,CAAC,MAAM,EAAE,oCAAoC,CAAC,QAAQ,CAAC,GAAG,IAAI;IAe9E;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAahE;;;OAGG;IACH,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAahE;;;;OAIG;IACH,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAclE;;;OAGG;IACH,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAgBlE;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQlE;;OAEG;IACH,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQhE;;OAEG;IACH,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQhE;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQ1D,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAY3D;;;;;;;;;;OAUG;IACH,OAAO,CAAC,OAAO;CAwGhB"}

package/dist/cjs/src/lib/confidentialTransferBuilder.js

@@ -0,0 +1,375 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfidentialTransferBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const web3_js_1 = require("@solana/web3.js");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const transaction_1 = require("./transaction");
+const transactionBuilder_1 = require("./transactionBuilder");
+const constants_1 = require("./constants");
+const compileTransactionMessage_1 = require("./serialization/compileTransactionMessage");
+const message_1 = require("./serialization/codecs/v1/message");
+const wire_transaction_1 = require("./serialization/wire-transaction");
+const solInstructionFactory_1 = require("./solInstructionFactory");
+const v1TransactionBuilder_1 = require("./v1TransactionBuilder");
+const assert_1 = __importDefault(require("assert"));
+/**
+ * Builder for Token-2022 confidential transfer transactions.
+ *
+ * Provides type-safe fluent setters for the following CT instructions:
+ * - CreateAssociatedTokenAccount (CT enablement: ATA under Token-2022 before ConfigureAccount)
+ * - ConfigureAccount (standalone, with VerifyPubkeyValidity proof)
+ * - ApplyPendingBalance (always instruction #1 in v1 spend txs, idempotent)
+ * - Deposit (public → confidential conversion)
+ * - Withdraw (confidential → public conversion, with equality + range proofs)
+ * - Transfer (confidential → confidential, with equality + validity + range proofs)
+ * - VerifyPubkeyValidity / VerifyEquality / VerifyValidity / VerifyRange proof instructions
+ *
+ * Instruction builders are v0/v1-agnostic: they produce instruction data and
+ * account metas only. The caller (Wallet Platform) assembles them into v1
+ * transactions in the correct order.
+ *
+ * @example
+ * ```ts
+ * const builder = factory.getConfidentialTransferBuilder();
+ * builder.nonce(recentBlockhash).sender(payer);
+ * builder.configureAccount({ tokenAddress, mintAddress, authorityAddress, ... });
+ * builder.verifyPubkeyValidity({ proofData });
+ * const tx = await builder.build();
+ * ```
+ */
+class ConfidentialTransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._ctInstructions = [];
+        this._transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.ConfidentialTransfer;
+    }
+    /**
+     * Set the Solana transaction version.
+     *
+     * Defaults to legacy until set. When set to `1`, the builder assembles a v1
+     * (SIMD-0296/0385) transaction: version byte `0x81`, an inline `transactionConfig`
+     * instead of ComputeBudget instructions, no address lookup tables, and a
+     * message-first wire format with signatures appended.
+     *
+     * @param version - the transaction version (0 = v0, 1 = v1)
+     * @returns {this} This builder
+     */
+    version(version) {
+        this._version = version;
+        return this;
+    }
+    /**
+     * Set the v1 transaction config (compute unit limit, heap size, loaded accounts
+     * data size limit, and priority fee as total lamports). Required when
+     * `version(1)` is set.
+     *
+     * @param config - the v1 transaction config
+     * @returns {this} This builder
+     */
+    transactionConfig(config) {
+        this._v1TransactionConfig = config;
+        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 programId - base58 encoded program id
+     */
+    zkProofProgramId(programId) {
+        (0, assert_1.default)(programId, 'Missing programId param');
+        this._zkProofProgramId = programId;
+        return this;
+    }
+    /** @inheritDoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        this._ctInstructions = [];
+        for (const instruction of this._instructionsData) {
+            switch (instruction.type) {
+                case constants_1.InstructionBuilderTypes.CreateAssociatedTokenAccount:
+                case constants_1.InstructionBuilderTypes.ReallocateConfidentialTransferAccount:
+                case constants_1.InstructionBuilderTypes.ConfigureConfidentialTransferAccount:
+                case constants_1.InstructionBuilderTypes.ApplyPendingBalance:
+                case constants_1.InstructionBuilderTypes.ConfidentialDeposit:
+                case constants_1.InstructionBuilderTypes.ConfidentialWithdraw:
+                case constants_1.InstructionBuilderTypes.ConfidentialTransfer:
+                case constants_1.InstructionBuilderTypes.VerifyPubkeyValidity:
+                case constants_1.InstructionBuilderTypes.VerifyEqualityProof:
+                case constants_1.InstructionBuilderTypes.VerifyValidityProof:
+                case constants_1.InstructionBuilderTypes.VerifyRangeProof:
+                    this._ctInstructions.push(instruction);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Add a CreateAssociatedTokenAccount (idempotent) instruction to the transaction.
+     * CT enablement only — the ATA must exist before ConfigureAccount; add this
+     * first when the ATA is not yet on-chain. For Token-2022 mints pass
+     * `programId` so the ATA is created under the Token-2022 program.
+     */
+    createAta(params) {
+        (0, assert_1.default)(params.mintAddress, 'Missing mintAddress param');
+        (0, assert_1.default)(params.ataAddress, 'Missing ataAddress param');
+        (0, assert_1.default)(params.ownerAddress, 'Missing ownerAddress param');
+        (0, assert_1.default)(params.payerAddress, 'Missing payerAddress param');
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.CreateAssociatedTokenAccount,
+            params,
+        });
+        // ConfigureAccount requires the ConfidentialTransferAccount extension, which an ATA does
+        // not carry — Reallocate adds it and must run before ConfigureAccount.
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.ReallocateConfidentialTransferAccount,
+            params: {
+                tokenAddress: params.ataAddress,
+                payerAddress: params.payerAddress,
+                ownerAddress: params.ownerAddress,
+                programId: params.programId,
+            },
+        });
+        return this;
+    }
+    /**
+     * Add a ConfigureAccount instruction to the transaction.
+     * One-time ATA setup — registers ElGamal pubkey + AES zero ciphertext.
+     * Must be accompanied by a VerifyPubkeyValidity proof instruction.
+     */
+    configureAccount(params) {
+        (0, assert_1.default)(params.tokenAddress, 'Missing tokenAddress param');
+        (0, assert_1.default)(params.mintAddress, 'Missing mintAddress param');
+        (0, assert_1.default)(params.authorityAddress, 'Missing authorityAddress param');
+        (0, assert_1.default)(params.elgamalPubkey, 'Missing elgamalPubkey param');
+        (0, assert_1.default)(params.decryptableZeroBalance, 'Missing decryptableZeroBalance param');
+        (0, assert_1.default)(params.maximumPendingBalanceCreditCounter, 'Missing maximumPendingBalanceCreditCounter param');
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.ConfigureConfidentialTransferAccount,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add an ApplyPendingBalance instruction to the transaction.
+     * Credits pending balance into available balance. Idempotent (no-op if 0 pending).
+     * In v1 transactions, this should always be instruction #1.
+     */
+    applyPendingBalance(params) {
+        (0, assert_1.default)(params.tokenAddress, 'Missing tokenAddress param');
+        (0, assert_1.default)(params.authorityAddress, 'Missing authorityAddress param');
+        (0, assert_1.default)(params.expectedPendingBalanceCreditCounter, 'Missing expectedPendingBalanceCreditCounter param');
+        (0, assert_1.default)(params.newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.ApplyPendingBalance,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add a Deposit instruction to the transaction.
+     * Moves public SPL tokens into confidential pending balance. No proof required.
+     */
+    confidentialDeposit(params) {
+        (0, assert_1.default)(params.tokenAddress, 'Missing tokenAddress param');
+        (0, assert_1.default)(params.mintAddress, 'Missing mintAddress param');
+        (0, assert_1.default)(params.authorityAddress, 'Missing authorityAddress param');
+        (0, assert_1.default)(params.amount, 'Missing amount param');
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.ConfidentialDeposit,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add a Withdraw instruction to the transaction.
+     * Moves confidential available balance to public balance.
+     * Requires equality + range proof verification instructions.
+     */
+    confidentialWithdraw(params) {
+        (0, assert_1.default)(params.tokenAddress, 'Missing tokenAddress param');
+        (0, assert_1.default)(params.mintAddress, 'Missing mintAddress param');
+        (0, assert_1.default)(params.authorityAddress, 'Missing authorityAddress param');
+        (0, assert_1.default)(params.amount, 'Missing amount param');
+        (0, assert_1.default)(params.newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.ConfidentialWithdraw,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add a confidential Transfer instruction to the transaction.
+     * Requires equality + ciphertext validity + range proof verification instructions.
+     */
+    confidentialTransfer(params) {
+        (0, assert_1.default)(params.sourceTokenAddress, 'Missing sourceTokenAddress param');
+        (0, assert_1.default)(params.mintAddress, 'Missing mintAddress param');
+        (0, assert_1.default)(params.destinationTokenAddress, 'Missing destinationTokenAddress param');
+        (0, assert_1.default)(params.authorityAddress, 'Missing authorityAddress param');
+        (0, assert_1.default)(params.newSourceDecryptableAvailableBalance, 'Missing newSourceDecryptableAvailableBalance param');
+        (0, assert_1.default)(params.transferAmountAuditorCiphertextLo, 'Missing transferAmountAuditorCiphertextLo param');
+        (0, assert_1.default)(params.transferAmountAuditorCiphertextHi, 'Missing transferAmountAuditorCiphertextHi param');
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.ConfidentialTransfer,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add a VerifyPubkeyValidity proof instruction (used with ConfigureAccount).
+     */
+    verifyPubkeyValidity(params) {
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.VerifyPubkeyValidity,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add a VerifyCiphertextCommitmentEquality proof instruction (used with Transfer and Withdraw).
+     */
+    verifyEqualityProof(params) {
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.VerifyEqualityProof,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add a VerifyBatchedGroupedCiphertext3HandlesValidity proof instruction (used with Transfer).
+     */
+    verifyValidityProof(params) {
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.VerifyValidityProof,
+            params,
+        });
+        return this;
+    }
+    /**
+     * Add a VerifyBatchedRangeProofU128 proof instruction (used with Transfer).
+     */
+    verifyRangeProof(params) {
+        this._ctInstructions.push({
+            type: constants_1.InstructionBuilderTypes.VerifyRangeProof,
+            params,
+        });
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        (0, assert_1.default)(this._ctInstructions.length > 0, 'At least one confidential transfer instruction must be specified');
+        if (this._version === 1) {
+            return this.buildV1();
+        }
+        this._instructionsData = [...this._ctInstructions];
+        return await super.buildImplementation();
+    }
+    /**
+     * Build a v1 (SIMD-0296/0385) confidential transfer transaction.
+     *
+     * Assembles the CT instructions via the shared instruction factory, compiles
+     * and serializes a v1 message with the inline transaction config, signs the
+     * message bytes with the builder's signers, and stores the resulting wire
+     * bytes for broadcast. Also populates a metadata-only SolTransaction so the
+     * transaction JSON and input/output extraction remain usable.
+     *
+     * @returns {Transaction} The built transaction holding the v1 wire bytes
+     */
+    buildV1() {
+        (0, assert_1.default)(this._sender, new sdk_core_1.BuildTransactionError('sender is required before building'));
+        (0, assert_1.default)(this._recentBlockhash, new sdk_core_1.BuildTransactionError('recent blockhash is required before building'));
+        (0, assert_1.default)(this._v1TransactionConfig, 'transactionConfig is required to build a v1 confidential transfer transaction');
+        // ApplyPendingBalance must remain instruction #1 in v1 spend txs (it is idempotent),
+        // regardless of the order the caller added instructions.
+        this._ctInstructions = [
+            ...this._ctInstructions.filter((i) => i.type === constants_1.InstructionBuilderTypes.ApplyPendingBalance),
+            ...this._ctInstructions.filter((i) => i.type !== constants_1.InstructionBuilderTypes.ApplyPendingBalance),
+        ];
+        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 and v1 payment-builder convention.
+        if (this._nonceInfo) {
+            instructions.push((0, v1TransactionBuilder_1.buildAdvanceNonceAccountInstruction)(this._nonceInfo.params.walletNonceAddress, this._nonceInfo.params.authWalletAddress));
+        }
+        for (const instruction of this._ctInstructions) {
+            instructions.push(...(0, solInstructionFactory_1.solInstructionFactory)(instruction, this._zkProofProgramId));
+        }
+        if (this._memo) {
+            const memoData = {
+                type: constants_1.InstructionBuilderTypes.Memo,
+                params: { memo: this._memo },
+            };
+            this._ctInstructions.push(memoData);
+            instructions.push(...(0, solInstructionFactory_1.solInstructionFactory)(memoData));
+        }
+        const feePayer = this._feePayer ? new web3_js_1.PublicKey(this._feePayer) : new web3_js_1.PublicKey(this._sender);
+        const messageBytes = (0, compileTransactionMessage_1.compileTransactionMessage)({
+            version: 1,
+            instructions,
+            feePayer,
+            recentBlockhash: this._recentBlockhash,
+            transactionConfig: this._v1TransactionConfig,
+        });
+        // 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). Missing
+        // signatures are zero-filled so unsigned/partial builds keep a valid wire
+        // shape for the server-side sign path (not broadcastable until filled).
+        const decoded = (0, message_1.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;
+                (0, assert_1.default)(secretKey instanceof Uint8Array, 'Missing private key');
+                signatures.push(tweetnacl_1.default.sign.detached(messageBytes, secretKey));
+                continue;
+            }
+            const additional = this.getAdditionalSignatures().find((sig) => sig.publicKey.pub === address);
+            if (additional) {
+                signatures.push(new Uint8Array(additional.signature));
+                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 = (0, wire_transaction_1.serializeWireTransaction)(messageBytes, signatures);
+        this._transaction.v1TransactionBytes = v1Wire;
+        this._transaction.v1MessageBytes = messageBytes;
+        // Populate a metadata-only SolTransaction so toJson / loadInputsAndOutputs work.
+        // The durable nonce is carried via nonceInfo, matching the v0 model.
+        const metaTx = new web3_js_1.Transaction();
+        metaTx.feePayer = feePayer;
+        metaTx.recentBlockhash = this._recentBlockhash;
+        if (this._nonceInfo) {
+            metaTx.nonceInfo = {
+                nonce: this._recentBlockhash,
+                nonceInstruction: (0, v1TransactionBuilder_1.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._ctInstructions);
+        this._transaction.loadInputsAndOutputs();
+        return this._transaction;
+    }
+}
+exports.ConfidentialTransferBuilder = ConfidentialTransferBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confidentialTransferBuilder.js","sourceRoot":"","sources":["../../../../src/lib/confidentialTransferBuilder.ts"],"names":[],"mappings":";;;;;;AACA,mDAA6H;AAC7H,6CAAmG;AACnG,0DAA6B;AAC7B,+CAA4C;AAC5C,6DAA0D;AAC1D,2CAAsD;AAetD,yFAAsF;AACtF,+DAAoE;AACpE,uEAA4E;AAC5E,mEAAgE;AAChE,iEAA6E;AAC7E,oDAA4B;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAa,2BAA4B,SAAQ,uCAAkB;IAKjE,YAAY,WAAiC;QAC3C,KAAK,CAAC,WAAW,CAAC,CAAC;QALb,oBAAe,GAAwB,EAAE,CAAC;QAMhD,IAAI,CAAC,YAAY,GAAG,IAAI,yBAAW,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED,IAAc,eAAe;QAC3B,OAAO,0BAAe,CAAC,oBAAoB,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;OAUG;IACH,OAAO,CAAC,OAA8B;QACpC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACH,iBAAiB,CAAC,MAA8B;QAC9C,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACH,gBAAgB,CAAC,SAAiB;QAChC,IAAA,gBAAM,EAAC,SAAS,EAAE,yBAAyB,CAAC,CAAC;QAC7C,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAe;QACzB,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACtB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACjD,QAAQ,WAAW,CAAC,IAAI,EAAE,CAAC;gBACzB,KAAK,mCAAuB,CAAC,4BAA4B,CAAC;gBAC1D,KAAK,mCAAuB,CAAC,qCAAqC,CAAC;gBACnE,KAAK,mCAAuB,CAAC,oCAAoC,CAAC;gBAClE,KAAK,mCAAuB,CAAC,mBAAmB,CAAC;gBACjD,KAAK,mCAAuB,CAAC,mBAAmB,CAAC;gBACjD,KAAK,mCAAuB,CAAC,oBAAoB,CAAC;gBAClD,KAAK,mCAAuB,CAAC,oBAAoB,CAAC;gBAClD,KAAK,mCAAuB,CAAC,oBAAoB,CAAC;gBAClD,KAAK,mCAAuB,CAAC,mBAAmB,CAAC;gBACjD,KAAK,mCAAuB,CAAC,mBAAmB,CAAC;gBACjD,KAAK,mCAAuB,CAAC,gBAAgB;oBAC3C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oBACvC,MAAM;gBACR;oBACE,MAAM;YACV,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,MAAyB;QACjC,IAAA,gBAAM,EAAC,MAAM,CAAC,WAAW,EAAE,2BAA2B,CAAC,CAAC;QACxD,IAAA,gBAAM,EAAC,MAAM,CAAC,UAAU,EAAE,0BAA0B,CAAC,CAAC;QACtD,IAAA,gBAAM,EAAC,MAAM,CAAC,YAAY,EAAE,4BAA4B,CAAC,CAAC;QAC1D,IAAA,gBAAM,EAAC,MAAM,CAAC,YAAY,EAAE,4BAA4B,CAAC,CAAC;QAE1D,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,4BAA4B;YAC1D,MAAM;SACP,CAAC,CAAC;QACH,yFAAyF;QACzF,uEAAuE;QACvE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,qCAAqC;YACnE,MAAM,EAAE;gBACN,YAAY,EAAE,MAAM,CAAC,UAAU;gBAC/B,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,SAAS,EAAE,MAAM,CAAC,SAAS;aAC5B;SACF,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,MAAsD;QACrE,IAAA,gBAAM,EAAC,MAAM,CAAC,YAAY,EAAE,4BAA4B,CAAC,CAAC;QAC1D,IAAA,gBAAM,EAAC,MAAM,CAAC,WAAW,EAAE,2BAA2B,CAAC,CAAC;QACxD,IAAA,gBAAM,EAAC,MAAM,CAAC,gBAAgB,EAAE,gCAAgC,CAAC,CAAC;QAClE,IAAA,gBAAM,EAAC,MAAM,CAAC,aAAa,EAAE,6BAA6B,CAAC,CAAC;QAC5D,IAAA,gBAAM,EAAC,MAAM,CAAC,sBAAsB,EAAE,sCAAsC,CAAC,CAAC;QAC9E,IAAA,gBAAM,EAAC,MAAM,CAAC,kCAAkC,EAAE,kDAAkD,CAAC,CAAC;QAEtG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,oCAAoC;YAClE,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,mBAAmB,CAAC,MAAqC;QACvD,IAAA,gBAAM,EAAC,MAAM,CAAC,YAAY,EAAE,4BAA4B,CAAC,CAAC;QAC1D,IAAA,gBAAM,EAAC,MAAM,CAAC,gBAAgB,EAAE,gCAAgC,CAAC,CAAC;QAClE,IAAA,gBAAM,EAAC,MAAM,CAAC,mCAAmC,EAAE,mDAAmD,CAAC,CAAC;QACxG,IAAA,gBAAM,EAAC,MAAM,CAAC,8BAA8B,EAAE,8CAA8C,CAAC,CAAC;QAE9F,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,mBAAmB;YACjD,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,mBAAmB,CAAC,MAAqC;QACvD,IAAA,gBAAM,EAAC,MAAM,CAAC,YAAY,EAAE,4BAA4B,CAAC,CAAC;QAC1D,IAAA,gBAAM,EAAC,MAAM,CAAC,WAAW,EAAE,2BAA2B,CAAC,CAAC;QACxD,IAAA,gBAAM,EAAC,MAAM,CAAC,gBAAgB,EAAE,gCAAgC,CAAC,CAAC;QAClE,IAAA,gBAAM,EAAC,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;QAE9C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,mBAAmB;YACjD,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,MAAsC;QACzD,IAAA,gBAAM,EAAC,MAAM,CAAC,YAAY,EAAE,4BAA4B,CAAC,CAAC;QAC1D,IAAA,gBAAM,EAAC,MAAM,CAAC,WAAW,EAAE,2BAA2B,CAAC,CAAC;QACxD,IAAA,gBAAM,EAAC,MAAM,CAAC,gBAAgB,EAAE,gCAAgC,CAAC,CAAC;QAClE,IAAA,gBAAM,EAAC,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;QAC9C,IAAA,gBAAM,EAAC,MAAM,CAAC,8BAA8B,EAAE,8CAA8C,CAAC,CAAC;QAE9F,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,oBAAoB;YAClD,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,oBAAoB,CAAC,MAAsC;QACzD,IAAA,gBAAM,EAAC,MAAM,CAAC,kBAAkB,EAAE,kCAAkC,CAAC,CAAC;QACtE,IAAA,gBAAM,EAAC,MAAM,CAAC,WAAW,EAAE,2BAA2B,CAAC,CAAC;QACxD,IAAA,gBAAM,EAAC,MAAM,CAAC,uBAAuB,EAAE,uCAAuC,CAAC,CAAC;QAChF,IAAA,gBAAM,EAAC,MAAM,CAAC,gBAAgB,EAAE,gCAAgC,CAAC,CAAC;QAClE,IAAA,gBAAM,EAAC,MAAM,CAAC,oCAAoC,EAAE,oDAAoD,CAAC,CAAC;QAC1G,IAAA,gBAAM,EAAC,MAAM,CAAC,iCAAiC,EAAE,iDAAiD,CAAC,CAAC;QACpG,IAAA,gBAAM,EAAC,MAAM,CAAC,iCAAiC,EAAE,iDAAiD,CAAC,CAAC;QAEpG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,oBAAoB;YAClD,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,oBAAoB,CAAC,MAAsC;QACzD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,oBAAoB;YAClD,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,MAAqC;QACvD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,mBAAmB;YACjD,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,MAAqC;QACvD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,mBAAmB;YACjD,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,MAAkC;QACjD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,IAAI,EAAE,mCAAuB,CAAC,gBAAgB;YAC9C,MAAM;SACP,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IACR,KAAK,CAAC,mBAAmB;QACjC,IAAA,gBAAM,EAAC,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,kEAAkE,CAAC,CAAC;QAE5G,IAAI,IAAI,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;QACxB,CAAC;QAED,IAAI,CAAC,iBAAiB,GAAG,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC;QAEnD,OAAO,MAAM,KAAK,CAAC,mBAAmB,EAAE,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;OAUG;IACK,OAAO;QACb,IAAA,gBAAM,EAAC,IAAI,CAAC,OAAO,EAAE,IAAI,gCAAqB,CAAC,oCAAoC,CAAC,CAAC,CAAC;QACtF,IAAA,gBAAM,EAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,gCAAqB,CAAC,8CAA8C,CAAC,CAAC,CAAC;QACzG,IAAA,gBAAM,EAAC,IAAI,CAAC,oBAAoB,EAAE,+EAA+E,CAAC,CAAC;QAEnH,qFAAqF;QACrF,yDAAyD;QACzD,IAAI,CAAC,eAAe,GAAG;YACrB,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,mCAAuB,CAAC,mBAAmB,CAAC;YAC7F,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,mCAAuB,CAAC,mBAAmB,CAAC;SAC9F,CAAC;QAEF,MAAM,YAAY,GAA6B,EAAE,CAAC;QAElD,yEAAyE;QACzE,wEAAwE;QACxE,2EAA2E;QAC3E,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,YAAY,CAAC,IAAI,CACf,IAAA,0DAAmC,EACjC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,kBAAkB,EACzC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,iBAAiB,CACzC,CACF,CAAC;QACJ,CAAC;QAED,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAC/C,YAAY,CAAC,IAAI,CAAC,GAAG,IAAA,6CAAqB,EAAC,WAAW,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC;QACnF,CAAC;QAED,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,QAAQ,GAAS;gBACrB,IAAI,EAAE,mCAAuB,CAAC,IAAI;gBAClC,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE;aAC7B,CAAC;YACF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACpC,YAAY,CAAC,IAAI,CAAC,GAAG,IAAA,6CAAqB,EAAC,QAAQ,CAAC,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,mBAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,mBAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9F,MAAM,YAAY,GAAG,IAAA,qDAAyB,EAAC;YAC7C,OAAO,EAAE,CAAC;YACV,YAAY;YACZ,QAAQ;YACR,eAAe,EAAE,IAAI,CAAC,gBAAgB;YACtC,iBAAiB,EAAE,IAAI,CAAC,oBAAoB;SAC7C,CAAC,CAAC;QAEH,0DAA0D;QAC1D,wEAAwE;QACxE,4EAA4E;QAC5E,0EAA0E;QAC1E,wEAAwE;QACxE,MAAM,OAAO,GAAG,IAAA,yBAAe,EAAC,YAAY,CAAC,CAAC;QAC9C,MAAM,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAE1F,MAAM,UAAU,GAAiB,EAAE,CAAC;QACpC,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;YACtC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;YACjF,IAAI,OAAO,EAAE,CAAC;gBACZ,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;gBAC5C,IAAA,gBAAM,EAAC,SAAS,YAAY,UAAU,EAAE,qBAAqB,CAAC,CAAC;gBAC/D,UAAU,CAAC,IAAI,CAAC,mBAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,CAAC;gBAC7D,SAAS;YACX,CAAC;YACD,MAAM,UAAU,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;YAC/F,IAAI,UAAU,EAAE,CAAC;gBACf,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;gBACtD,SAAS;YACX,CAAC;YACD,sEAAsE;YACtE,qEAAqE;YACrE,yCAAyC;YACzC,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;QACtC,CAAC;QAED,MAAM,MAAM,GAAG,IAAA,2CAAwB,EAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QAElE,IAAI,CAAC,YAAY,CAAC,kBAAkB,GAAG,MAAM,CAAC;QAC9C,IAAI,CAAC,YAAY,CAAC,cAAc,GAAG,YAAY,CAAC;QAEhD,iFAAiF;QACjF,qEAAqE;QACrE,MAAM,MAAM,GAAG,IAAI,qBAAc,EAAE,CAAC;QACpC,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAC3B,MAAM,CAAC,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC/C,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,MAAM,CAAC,SAAS,GAAG;gBACjB,KAAK,EAAE,IAAI,CAAC,gBAAgB;gBAC5B,gBAAgB,EAAE,IAAA,0DAAmC,EACnD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,kBAAkB,EACzC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,iBAAiB,CACzC;aACF,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;QAC5B,IAAI,CAAC,YAAY,CAAC,cAAc,GAAG,MAAM,CAAC;QAE1C,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC3D,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,CAAC,oBAAoB,EAAE,CAAC;QAEzC,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;CACF;AA3XD,kEA2XC","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BuildTransactionError, SolTransactionVersion, SolV1TransactionConfig, TransactionType } from '@bitgo-beta/sdk-core';\nimport { PublicKey, Transaction as SolTransaction, TransactionInstruction } from '@solana/web3.js';\nimport nacl from 'tweetnacl';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { InstructionBuilderTypes } from './constants';\nimport {\n  ApplyPendingBalance,\n  AtaInit,\n  ConfidentialDeposit,\n  ConfidentialTransfer,\n  ConfidentialWithdraw,\n  ConfigureConfidentialTransferAccount,\n  InstructionParams,\n  Memo,\n  VerifyEqualityProof,\n  VerifyPubkeyValidity,\n  VerifyRangeProof,\n  VerifyValidityProof,\n} from './iface';\nimport { compileTransactionMessage } from './serialization/compileTransactionMessage';\nimport { decodeV1Message } from './serialization/codecs/v1/message';\nimport { serializeWireTransaction } from './serialization/wire-transaction';\nimport { solInstructionFactory } from './solInstructionFactory';\nimport { buildAdvanceNonceAccountInstruction } from './v1TransactionBuilder';\nimport assert from 'assert';\n\n/**\n * Builder for Token-2022 confidential transfer transactions.\n *\n * Provides type-safe fluent setters for the following CT instructions:\n * - CreateAssociatedTokenAccount (CT enablement: ATA under Token-2022 before ConfigureAccount)\n * - ConfigureAccount (standalone, with VerifyPubkeyValidity proof)\n * - ApplyPendingBalance (always instruction #1 in v1 spend txs, idempotent)\n * - Deposit (public → confidential conversion)\n * - Withdraw (confidential → public conversion, with equality + range proofs)\n * - Transfer (confidential → confidential, with equality + validity + range proofs)\n * - VerifyPubkeyValidity / VerifyEquality / VerifyValidity / VerifyRange proof instructions\n *\n * Instruction builders are v0/v1-agnostic: they produce instruction data and\n * account metas only. The caller (Wallet Platform) assembles them into v1\n * transactions in the correct order.\n *\n * @example\n * ```ts\n * const builder = factory.getConfidentialTransferBuilder();\n * builder.nonce(recentBlockhash).sender(payer);\n * builder.configureAccount({ tokenAddress, mintAddress, authorityAddress, ... });\n * builder.verifyPubkeyValidity({ proofData });\n * const tx = await builder.build();\n * ```\n */\nexport class ConfidentialTransferBuilder extends TransactionBuilder {\n  private _ctInstructions: InstructionParams[] = [];\n  private _version?: SolTransactionVersion;\n  private _v1TransactionConfig?: SolV1TransactionConfig;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.ConfidentialTransfer;\n  }\n\n  /**\n   * Set the Solana transaction version.\n   *\n   * Defaults to legacy until set. When set to `1`, the builder assembles a v1\n   * (SIMD-0296/0385) transaction: version byte `0x81`, an inline `transactionConfig`\n   * instead of ComputeBudget instructions, no address lookup tables, and a\n   * message-first wire format with signatures appended.\n   *\n   * @param version - the transaction version (0 = v0, 1 = v1)\n   * @returns {this} This builder\n   */\n  version(version: SolTransactionVersion): this {\n    this._version = version;\n    return this;\n  }\n\n  /**\n   * Set the v1 transaction config (compute unit limit, heap size, loaded accounts\n   * data size limit, and priority fee as total lamports). Required when\n   * `version(1)` is set.\n   *\n   * @param config - the v1 transaction config\n   * @returns {this} This builder\n   */\n  transactionConfig(config: SolV1TransactionConfig): this {\n    this._v1TransactionConfig = config;\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 programId - base58 encoded program id\n   */\n  zkProofProgramId(programId: string): this {\n    assert(programId, 'Missing programId param');\n    this._zkProofProgramId = programId;\n    return this;\n  }\n\n  /** @inheritDoc */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    this._ctInstructions = [];\n    for (const instruction of this._instructionsData) {\n      switch (instruction.type) {\n        case InstructionBuilderTypes.CreateAssociatedTokenAccount:\n        case InstructionBuilderTypes.ReallocateConfidentialTransferAccount:\n        case InstructionBuilderTypes.ConfigureConfidentialTransferAccount:\n        case InstructionBuilderTypes.ApplyPendingBalance:\n        case InstructionBuilderTypes.ConfidentialDeposit:\n        case InstructionBuilderTypes.ConfidentialWithdraw:\n        case InstructionBuilderTypes.ConfidentialTransfer:\n        case InstructionBuilderTypes.VerifyPubkeyValidity:\n        case InstructionBuilderTypes.VerifyEqualityProof:\n        case InstructionBuilderTypes.VerifyValidityProof:\n        case InstructionBuilderTypes.VerifyRangeProof:\n          this._ctInstructions.push(instruction);\n          break;\n        default:\n          break;\n      }\n    }\n  }\n\n  /**\n   * Add a CreateAssociatedTokenAccount (idempotent) instruction to the transaction.\n   * CT enablement only — the ATA must exist before ConfigureAccount; add this\n   * first when the ATA is not yet on-chain. For Token-2022 mints pass\n   * `programId` so the ATA is created under the Token-2022 program.\n   */\n  createAta(params: AtaInit['params']): this {\n    assert(params.mintAddress, 'Missing mintAddress param');\n    assert(params.ataAddress, 'Missing ataAddress param');\n    assert(params.ownerAddress, 'Missing ownerAddress param');\n    assert(params.payerAddress, 'Missing payerAddress param');\n\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n      params,\n    });\n    // ConfigureAccount requires the ConfidentialTransferAccount extension, which an ATA does\n    // not carry — Reallocate adds it and must run before ConfigureAccount.\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.ReallocateConfidentialTransferAccount,\n      params: {\n        tokenAddress: params.ataAddress,\n        payerAddress: params.payerAddress,\n        ownerAddress: params.ownerAddress,\n        programId: params.programId,\n      },\n    });\n    return this;\n  }\n\n  /**\n   * Add a ConfigureAccount instruction to the transaction.\n   * One-time ATA setup — registers ElGamal pubkey + AES zero ciphertext.\n   * Must be accompanied by a VerifyPubkeyValidity proof instruction.\n   */\n  configureAccount(params: ConfigureConfidentialTransferAccount['params']): this {\n    assert(params.tokenAddress, 'Missing tokenAddress param');\n    assert(params.mintAddress, 'Missing mintAddress param');\n    assert(params.authorityAddress, 'Missing authorityAddress param');\n    assert(params.elgamalPubkey, 'Missing elgamalPubkey param');\n    assert(params.decryptableZeroBalance, 'Missing decryptableZeroBalance param');\n    assert(params.maximumPendingBalanceCreditCounter, 'Missing maximumPendingBalanceCreditCounter param');\n\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.ConfigureConfidentialTransferAccount,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add an ApplyPendingBalance instruction to the transaction.\n   * Credits pending balance into available balance. Idempotent (no-op if 0 pending).\n   * In v1 transactions, this should always be instruction #1.\n   */\n  applyPendingBalance(params: ApplyPendingBalance['params']): this {\n    assert(params.tokenAddress, 'Missing tokenAddress param');\n    assert(params.authorityAddress, 'Missing authorityAddress param');\n    assert(params.expectedPendingBalanceCreditCounter, 'Missing expectedPendingBalanceCreditCounter param');\n    assert(params.newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');\n\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.ApplyPendingBalance,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add a Deposit instruction to the transaction.\n   * Moves public SPL tokens into confidential pending balance. No proof required.\n   */\n  confidentialDeposit(params: ConfidentialDeposit['params']): this {\n    assert(params.tokenAddress, 'Missing tokenAddress param');\n    assert(params.mintAddress, 'Missing mintAddress param');\n    assert(params.authorityAddress, 'Missing authorityAddress param');\n    assert(params.amount, 'Missing amount param');\n\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.ConfidentialDeposit,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add a Withdraw instruction to the transaction.\n   * Moves confidential available balance to public balance.\n   * Requires equality + range proof verification instructions.\n   */\n  confidentialWithdraw(params: ConfidentialWithdraw['params']): this {\n    assert(params.tokenAddress, 'Missing tokenAddress param');\n    assert(params.mintAddress, 'Missing mintAddress param');\n    assert(params.authorityAddress, 'Missing authorityAddress param');\n    assert(params.amount, 'Missing amount param');\n    assert(params.newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');\n\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.ConfidentialWithdraw,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add a confidential Transfer instruction to the transaction.\n   * Requires equality + ciphertext validity + range proof verification instructions.\n   */\n  confidentialTransfer(params: ConfidentialTransfer['params']): this {\n    assert(params.sourceTokenAddress, 'Missing sourceTokenAddress param');\n    assert(params.mintAddress, 'Missing mintAddress param');\n    assert(params.destinationTokenAddress, 'Missing destinationTokenAddress param');\n    assert(params.authorityAddress, 'Missing authorityAddress param');\n    assert(params.newSourceDecryptableAvailableBalance, 'Missing newSourceDecryptableAvailableBalance param');\n    assert(params.transferAmountAuditorCiphertextLo, 'Missing transferAmountAuditorCiphertextLo param');\n    assert(params.transferAmountAuditorCiphertextHi, 'Missing transferAmountAuditorCiphertextHi param');\n\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.ConfidentialTransfer,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add a VerifyPubkeyValidity proof instruction (used with ConfigureAccount).\n   */\n  verifyPubkeyValidity(params: VerifyPubkeyValidity['params']): this {\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.VerifyPubkeyValidity,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add a VerifyCiphertextCommitmentEquality proof instruction (used with Transfer and Withdraw).\n   */\n  verifyEqualityProof(params: VerifyEqualityProof['params']): this {\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.VerifyEqualityProof,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add a VerifyBatchedGroupedCiphertext3HandlesValidity proof instruction (used with Transfer).\n   */\n  verifyValidityProof(params: VerifyValidityProof['params']): this {\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.VerifyValidityProof,\n      params,\n    });\n    return this;\n  }\n\n  /**\n   * Add a VerifyBatchedRangeProofU128 proof instruction (used with Transfer).\n   */\n  verifyRangeProof(params: VerifyRangeProof['params']): this {\n    this._ctInstructions.push({\n      type: InstructionBuilderTypes.VerifyRangeProof,\n      params,\n    });\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._ctInstructions.length > 0, 'At least one confidential transfer instruction must be specified');\n\n    if (this._version === 1) {\n      return this.buildV1();\n    }\n\n    this._instructionsData = [...this._ctInstructions];\n\n    return await super.buildImplementation();\n  }\n\n  /**\n   * Build a v1 (SIMD-0296/0385) confidential transfer transaction.\n   *\n   * Assembles the CT instructions via the shared instruction factory, compiles\n   * and serializes a v1 message with the inline transaction config, signs the\n   * message bytes with the builder's signers, and stores the resulting wire\n   * bytes for broadcast. Also populates a metadata-only SolTransaction so the\n   * transaction JSON and input/output extraction remain usable.\n   *\n   * @returns {Transaction} The built transaction holding the v1 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._v1TransactionConfig, 'transactionConfig is required to build a v1 confidential transfer transaction');\n\n    // ApplyPendingBalance must remain instruction #1 in v1 spend txs (it is idempotent),\n    // regardless of the order the caller added instructions.\n    this._ctInstructions = [\n      ...this._ctInstructions.filter((i) => i.type === InstructionBuilderTypes.ApplyPendingBalance),\n      ...this._ctInstructions.filter((i) => i.type !== InstructionBuilderTypes.ApplyPendingBalance),\n    ];\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 and v1 payment-builder 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._ctInstructions) {\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._ctInstructions.push(memoData);\n      instructions.push(...solInstructionFactory(memoData));\n    }\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._v1TransactionConfig,\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). Missing\n    // signatures are zero-filled so unsigned/partial builds keep a valid wire\n    // shape for the server-side sign path (not broadcastable until filled).\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 additional = this.getAdditionalSignatures().find((sig) => sig.publicKey.pub === address);\n      if (additional) {\n        signatures.push(new Uint8Array(additional.signature));\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\n    // Populate a metadata-only SolTransaction so toJson / loadInputsAndOutputs work.\n    // 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._ctInstructions);\n    this._transaction.loadInputsAndOutputs();\n\n    return this._transaction;\n  }\n}\n"]}