@bitgo-beta/sdk-coin-sol 7.6.4-beta.709 → 7.6.4-beta.710

package/dist/esm/lib/confidentialTransferBuilder.d.ts

@@ -1,5 +1,5 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-import { TransactionType } from '@bitgo-beta/sdk-core';
+import { SolTransactionVersion, SolV1TransactionConfig, TransactionType } from '@bitgo-beta/sdk-core';
 import { Transaction } from './transaction';
 import { TransactionBuilder } from './transactionBuilder';
 import { ApplyPendingBalance, ConfidentialDeposit, ConfidentialTransfer, ConfidentialWithdraw, ConfigureConfidentialTransferAccount, VerifyEqualityProof, VerifyPubkeyValidity, VerifyRangeProof, VerifyValidityProof } from './iface';
@@ -29,8 +29,31 @@ import { ApplyPendingBalance, ConfidentialDeposit, ConfidentialTransfer, Confide
  */
 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.
      *
@@ -89,5 +112,17 @@ export declare class ConfidentialTransferBuilder extends TransactionBuilder {
     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/esm/lib/confidentialTransferBuilder.d.ts.map

@@ -1 +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,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,oCAAoC,EAEpC,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAGjB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,2BAA4B,SAAQ,kBAAkB;IACjE,OAAO,CAAC,eAAe,CAA2B;gBAEtC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;;;;OAQG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAMzC,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAsBlC;;;;OAIG;IACH,gBAAgB,CAAC,MAAM,EAAE,oCAAoC,CAAC,QAAQ,CAAC,GAAG,IAAI;IAc9E;;;;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;CAO5D"}
+{"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,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,oCAAoC,EAGpC,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAMjB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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;IAsBlC;;;;OAIG;IACH,gBAAgB,CAAC,MAAM,EAAE,oCAAoC,CAAC,QAAQ,CAAC,GAAG,IAAI;IAc9E;;;;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;CA+DhB"}

package/dist/esm/lib/confidentialTransferBuilder.js

@@ -1,7 +1,12 @@
-import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { PublicKey, Transaction as SolTransaction } from '@solana/web3.js';
+import nacl from 'tweetnacl';
 import { Transaction } from './transaction';
 import { TransactionBuilder } from './transactionBuilder';
 import { InstructionBuilderTypes } from './constants';
+import { compileTransactionMessage } from './serialization/compileTransactionMessage';
+import { serializeWireTransaction } from './serialization/wire-transaction';
+import { solInstructionFactory } from './solInstructionFactory';
 import assert from 'assert';
 /**
  * Builder for Token-2022 confidential transfer transactions.
@@ -36,6 +41,33 @@ export class ConfidentialTransferBuilder extends TransactionBuilder {
     get transactionType() {
         return 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.
      *
@@ -198,8 +230,75 @@ export class ConfidentialTransferBuilder extends TransactionBuilder {
     /** @inheritdoc */
     async buildImplementation() {
         assert(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() {
+        assert(this._sender, new BuildTransactionError('sender is required before building'));
+        assert(this._recentBlockhash, new BuildTransactionError('recent blockhash is required before building'));
+        assert(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 === InstructionBuilderTypes.ApplyPendingBalance),
+            ...this._ctInstructions.filter((i) => i.type !== InstructionBuilderTypes.ApplyPendingBalance),
+        ];
+        const instructions = [];
+        for (const instruction of this._ctInstructions) {
+            instructions.push(...solInstructionFactory(instruction, this._zkProofProgramId));
+        }
+        if (this._memo) {
+            const memoData = {
+                type: InstructionBuilderTypes.Memo,
+                params: { memo: this._memo },
+            };
+            this._ctInstructions.push(memoData);
+            instructions.push(...solInstructionFactory(memoData));
+        }
+        const feePayer = this._feePayer ? new PublicKey(this._feePayer) : new PublicKey(this._sender);
+        const messageBytes = compileTransactionMessage({
+            version: 1,
+            instructions,
+            feePayer,
+            recentBlockhash: this._recentBlockhash,
+            transactionConfig: this._v1TransactionConfig,
+        });
+        const signatures = [];
+        for (const signer of this._signers) {
+            const secretKey = signer.getKeys(true).prv;
+            assert(secretKey instanceof Uint8Array, 'Missing private key');
+            signatures.push(nacl.sign.detached(messageBytes, secretKey));
+        }
+        for (const signature of this.getAdditionalSignatures()) {
+            signatures.push(new Uint8Array(signature.signature));
+        }
+        const v1Wire = serializeWireTransaction(messageBytes, signatures);
+        this._transaction.v1TransactionBytes = v1Wire;
+        this._transaction.v1MessageBytes = messageBytes;
+        // Populate a metadata-only SolTransaction so toJson / loadInputsAndOutputs work.
+        const metaTx = new SolTransaction();
+        metaTx.feePayer = feePayer;
+        metaTx.recentBlockhash = this._recentBlockhash;
+        metaTx.add(...instructions);
+        this._transaction.solTransaction = metaTx;
+        this._transaction.setTransactionType(this.transactionType);
+        this._transaction.setInstructionsData(this._ctInstructions);
+        this._transaction.loadInputsAndOutputs();
+        return this._transaction;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confidentialTransferBuilder.js","sourceRoot":"","sources":["../../../src/lib/confidentialTransferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { InstructionBuilderTypes } from './constants';\nimport {\n  ApplyPendingBalance,\n  ConfidentialDeposit,\n  ConfidentialTransfer,\n  ConfidentialWithdraw,\n  ConfigureConfidentialTransferAccount,\n  InstructionParams,\n  VerifyEqualityProof,\n  VerifyPubkeyValidity,\n  VerifyRangeProof,\n  VerifyValidityProof,\n} from './iface';\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 * - 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\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   * 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.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 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.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    this._instructionsData = [...this._ctInstructions];\n\n    return await super.buildImplementation();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confidentialTransferBuilder.js","sourceRoot":"","sources":["../../../src/lib/confidentialTransferBuilder.ts"],"names":[],"mappings":"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","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  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 { serializeWireTransaction } from './serialization/wire-transaction';\nimport { solInstructionFactory } from './solInstructionFactory';\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 * - 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.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 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.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    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    const signatures: Uint8Array[] = [];\n    for (const signer of this._signers) {\n      const secretKey = signer.getKeys(true).prv;\n      assert(secretKey instanceof Uint8Array, 'Missing private key');\n      signatures.push(nacl.sign.detached(messageBytes, secretKey));\n    }\n    for (const signature of this.getAdditionalSignatures()) {\n      signatures.push(new Uint8Array(signature.signature));\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    const metaTx = new SolTransaction();\n    metaTx.feePayer = feePayer;\n    metaTx.recentBlockhash = this._recentBlockhash;\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"]}

package/dist/esm/lib/transaction.d.ts

@@ -13,6 +13,8 @@ export declare class Transaction extends BaseTransaction {
     private _useTokenAddressTokenName;
     private _versionedTransaction;
     private _versionedTransactionData;
+    private _v1TransactionBytes;
+    private _v1MessageBytes;
     constructor(_coinConfig: Readonly<CoinConfig>);
     get solTransaction(): SolTransaction;
     set solTransaction(tx: SolTransaction);
@@ -47,6 +49,26 @@ export declare class Transaction extends BaseTransaction {
      * @returns {boolean} True if this is a VersionedTransaction
      */
     isVersionedTransaction(): boolean;
+    /**
+     * Get the serialized v1 wire transaction bytes (message + signatures), if this transaction is v1
+     * @returns {Uint8Array | undefined} The v1 wire bytes or undefined
+     */
+    get v1TransactionBytes(): Uint8Array | undefined;
+    /**
+     * Set the serialized v1 wire transaction bytes (message + signatures)
+     * @param {Uint8Array | undefined} bytes The v1 wire bytes to store, or undefined to clear
+     */
+    set v1TransactionBytes(bytes: Uint8Array | undefined);
+    /**
+     * Get the serialized v1 message bytes (without signatures), if this transaction is v1
+     * @returns {Uint8Array | undefined} The v1 message bytes or undefined
+     */
+    get v1MessageBytes(): Uint8Array | undefined;
+    /**
+     * Set the serialized v1 message bytes (without signatures)
+     * @param {Uint8Array | undefined} bytes The v1 message bytes to store, or undefined to clear
+     */
+    set v1MessageBytes(bytes: Uint8Array | undefined);
     /**
      * Get the original VersionedTransaction if this transaction was parsed from one
      * @returns {VersionedTransaction | undefined} The VersionedTransaction or undefined

package/dist/esm/lib/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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"}