@bitgo-beta/sdk-coin-sol 7.6.4-beta.70 → 7.6.4-beta.700

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

@@ -0,0 +1,93 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { 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';
+/**
+ * Builder for Token-2022 confidential transfer transactions.
+ *
+ * Provides type-safe fluent setters for the following CT instructions:
+ * - 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;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /**
+     * 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 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>;
+}
+//# 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,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"}

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

@@ -0,0 +1,212 @@
+"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 transaction_1 = require("./transaction");
+const transactionBuilder_1 = require("./transactionBuilder");
+const constants_1 = require("./constants");
+const assert_1 = __importDefault(require("assert"));
+/**
+ * Builder for Token-2022 confidential transfer transactions.
+ *
+ * Provides type-safe fluent setters for the following CT instructions:
+ * - 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;
+    }
+    /**
+     * 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.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 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.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');
+        this._instructionsData = [...this._ctInstructions];
+        return await super.buildImplementation();
+    }
+}
+exports.ConfidentialTransferBuilder = ConfidentialTransferBuilder;
+//# 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"]}

package/dist/{src → cjs/src}/lib/constants.d.ts

@@ -4,12 +4,72 @@ export declare const SEED_LENGTH = 32;
 export declare const MAX_MEMO_LENGTH = 130;
 export declare const STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT = 2282880;
 export declare const UNAVAILABLE_TEXT = "UNAVAILABLE";
+/**
+ * Sysvar instructions account address — used by Token-2022 confidential transfer
+ * instructions to locate inline proof verification instructions in the same transaction.
+ */
+export declare const INSTRUCTIONS_SYSVAR_ADDRESS = "Sysvar1nstructions1111111111111111111111111";
+/**
+ * Canonical on-chain program id of the zk-elgamal-proof program.
+ *
+ * This is the same across mainnet, devnet, and testnet — it is a native
+ * built-in program. Callers can override via ConfidentialTransferBuilder
+ * .zkProofProgramId() if targeting a custom deployment.
+ *
+ * Note: The deprecated zk-token-proof program id is
+ * `ZkTokenProof1111111111111111111111111111111`.
+ */
+export declare const ZK_ELGAMAL_PROOF_PROGRAM_ID = "ZkE1Gama1Proof11111111111111111111111111111";
+/**
+ * Token-2022 confidential transfer extension discriminator (byte 0 of instruction data).
+ */
+export declare const CT_EXT_DISCRIMINATOR = 27;
+/**
+ * Valid CT sub-instruction discriminators (byte 1 after CT_EXT_DISCRIMINATOR).
+ * Used for transaction type detection (getTransactionType / deriveTransactionType).
+ */
+export declare const CT_SUB_DISCRIMINATORS: Set<number>;
+/**
+ * Maximum over-the-wire size of a Solana transaction (in bytes)
+ *
+ * Source: https://github.com/anza-xyz/agave/blob/v2.1.13/sdk/packet/src/lib.rs#L27-L29
+ *
+ * Calculation:
+ * - IPv6 minimum MTU: 1280 bytes
+ * - IPv6 header: 40 bytes
+ * - Fragment/UDP header: 8 bytes
+ * - Result: 1280 - 40 - 8 = 1232 bytes
+ *
+ * This limit is designed to avoid packet fragmentation on typical internet infrastructure.
+ * Transactions exceeding this limit will fail to serialize with a RangeError during
+ * the encoding of the transaction message.
+ *
+ * Reference: https://solana.com/docs/core/transactions#transaction-size
+ */
+export declare const SOLANA_TRANSACTION_MAX_SIZE = 1232;
 export declare const JITO_STAKE_POOL_ADDRESS = "Jito4APyf642JPZPx3hGc6WWJ8zPKtRbRs4P815Awbb";
 export declare const JITOSOL_MINT_ADDRESS = "J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn";
 export declare const JITO_STAKE_POOL_RESERVE_ACCOUNT = "BgKUXdS29YcHCFrPm5M8oLHiTzZaMDjsebggjoaQ6KFL";
 export declare const JITO_STAKE_POOL_RESERVE_ACCOUNT_TESTNET = "rrWBQqRqBXYZw3CmPCCcjFxQ2Ds4JFJd7oRQJ997dhz";
 export declare const JITO_MANAGER_FEE_ACCOUNT = "feeeFLLsam6xZJFc6UQFrHqkvVt4jfmVvi2BRLkUZ4i";
 export declare const JITO_MANAGER_FEE_ACCOUNT_TESTNET = "DH7tmjoQ5zjqcgfYJU22JqmXhP5EY1tkbYpgVWUS2oNo";
+/**
+ * On-chain program id of the sRFC-37 Token ACL program. This single program gates every
+ * allowlist/blocklist (DefaultAccountState) Token-2022 mint, so the value is generic and never
+ * tied to a specific issuer.
+ */
+export declare const TOKEN_ACL_PROGRAM_ID = "TACLkU6CiCdkQN2MjoyDkVg2yAH9zkxiHDsiztQ52TP";
+/**
+ * Instruction discriminator (a single u8 byte) for the Token ACL `ThawPermissionlessIdempotent`
+ * instruction.
+ */
+export declare const THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR = 9;
+/** PDA seed prefix (under the Token ACL program) for a mint's MintConfig account. */
+export declare const TOKEN_ACL_MINT_CONFIG_SEED = "MINT_CONFIG";
+/** PDA seed prefix (under the Token ACL program) for a token account's thaw flag account. */
+export declare const TOKEN_ACL_FLAG_ACCOUNT_SEED = "FLAG_ACCOUNT";
+/** PDA seed prefix (under the gating program) for a mint's thaw ExtraAccountMetaList account. */
+export declare const TOKEN_ACL_THAW_EXTRA_METAS_SEED = "thaw_extra_account_metas";
 export declare enum ValidInstructionTypesEnum {
     AdvanceNonceAccount = "AdvanceNonceAccount",
     Create = "Create",
@@ -23,6 +83,7 @@ export declare enum ValidInstructionTypesEnum {
     Memo = "Memo",
     InitializeAssociatedTokenAccount = "InitializeAssociatedTokenAccount",
     CloseAssociatedTokenAccount = "CloseAssociatedTokenAccount",
+    RecoverNestedAssociatedTokenAccount = "RecoverNestedAssociatedTokenAccount",
     Allocate = "Allocate",
     Assign = "Assign",
     Split = "Split",
@@ -33,8 +94,19 @@ export declare enum ValidInstructionTypesEnum {
     Burn = "Burn",
     DepositSol = "DepositSol",
     WithdrawStake = "WithdrawStake",
+    WithdrawSol = "WithdrawSol",
     Approve = "Approve",
-    CustomInstruction = "CustomInstruction"
+    CustomInstruction = "CustomInstruction",
+    PermissionlessThawIdempotent = "PermissionlessThawIdempotent",
+    ConfigureConfidentialTransferAccount = "ConfigureConfidentialTransferAccount",
+    ApplyPendingBalance = "ApplyPendingBalance",
+    ConfidentialDeposit = "ConfidentialDeposit",
+    ConfidentialWithdraw = "ConfidentialWithdraw",
+    ConfidentialTransfer = "ConfidentialTransfer",
+    VerifyPubkeyValidity = "VerifyPubkeyValidity",
+    VerifyEqualityProof = "VerifyEqualityProof",
+    VerifyValidityProof = "VerifyValidityProof",
+    VerifyRangeProof = "VerifyRangeProof"
 }
 export declare enum InstructionBuilderTypes {
     CreateNonceAccount = "CreateNonceAccount",
@@ -46,6 +118,7 @@ export declare enum InstructionBuilderTypes {
     NonceAdvance = "NonceAdvance",
     CreateAssociatedTokenAccount = "CreateAssociatedTokenAccount",
     CloseAssociatedTokenAccount = "CloseAssociatedTokenAccount",
+    RecoverNestedAssociatedTokenAccount = "RecoverNestedAssociatedTokenAccount",
     TokenTransfer = "TokenTransfer",
     StakingAuthorize = "Authorize",
     StakingDelegate = "Delegate",
@@ -56,7 +129,17 @@ export declare enum InstructionBuilderTypes {
     CustomInstruction = "CustomInstruction",
     VersionedCustomInstruction = "VersionedCustomInstruction",
     Approve = "Approve",
-    WithdrawStake = "WithdrawStake"
+    WithdrawStake = "WithdrawStake",
+    PermissionlessThawIdempotent = "PermissionlessThawIdempotent",
+    ConfigureConfidentialTransferAccount = "ConfigureConfidentialTransferAccount",
+    ApplyPendingBalance = "ApplyPendingBalance",
+    ConfidentialDeposit = "ConfidentialDeposit",
+    ConfidentialWithdraw = "ConfidentialWithdraw",
+    ConfidentialTransfer = "ConfidentialTransfer",
+    VerifyPubkeyValidity = "VerifyPubkeyValidity",
+    VerifyEqualityProof = "VerifyEqualityProof",
+    VerifyValidityProof = "VerifyValidityProof",
+    VerifyRangeProof = "VerifyRangeProof"
 }
 export declare const VALID_SYSTEM_INSTRUCTION_TYPES: ValidInstructionTypes[];
 /** Const to check the order of the Wallet Init instructions when decode */
@@ -134,6 +217,10 @@ export declare const ataInitInstructionIndexes: {
 export declare const ataCloseInstructionIndexes: {
     readonly CloseAssociatedTokenAccount: 0;
 };
+/** Const to check the order of the recover nested ATA instructions when decode */
+export declare const ataRecoverNestedInstructionIndexes: {
+    readonly RecoverNestedAssociatedTokenAccount: 0;
+};
 export declare const nonceAdvanceInstruction = "AdvanceNonceAccount";
 export declare const validInstructionData = "0a00000001000000";
 export declare const validInstructionData2 = "0a00000000000000";

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

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