feat(sdk-coin-sol): route confidential transfers through v1

Add version(1)/transactionConfig setters to the confidential transfer
builder and assemble v1 transactions (0x81, inline config, message-first
wire format) via the v1 compiler/serializer. Persist the v1 wire and
message bytes on the transaction, expose them through toBroadcastFormat,
signablePayload, and id, and guard v1 broadcast size against the 4096-byte
limit. Add unit tests for the v1 CT path.

Refs: CHALO-1602

Author: bhavidhingra

modules/sdk-coin-sol/src/lib/confidentialTransferBuilder.ts

@@ -1,5 +1,7 @@
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { TransactionType } from '@bitgo/sdk-core';
+import { BuildTransactionError, SolTransactionVersion, SolV1TransactionConfig, TransactionType } from '@bitgo/sdk-core';
+import { PublicKey, Transaction as SolTransaction, TransactionInstruction } from '@solana/web3.js';
+import nacl from 'tweetnacl';
 import { Transaction } from './transaction';
 import { TransactionBuilder } from './transactionBuilder';
 import { InstructionBuilderTypes } from './constants';
@@ -10,11 +12,15 @@ import {
   ConfidentialWithdraw,
   ConfigureConfidentialTransferAccount,
   InstructionParams,
+  Memo,
   VerifyEqualityProof,
   VerifyPubkeyValidity,
   VerifyRangeProof,
   VerifyValidityProof,
 } from './iface';
+import { compileV1Message } from './v1/compileV1Message';
+import { serializeV1Transaction } from './v1/serializeV1Transaction';
+import { solInstructionFactory } from './solInstructionFactory';
 import assert from 'assert';
 
 /**
@@ -43,6 +49,8 @@ import assert from 'assert';
  */
 export class ConfidentialTransferBuilder extends TransactionBuilder {
   private _ctInstructions: InstructionParams[] = [];
+  private _version?: SolTransactionVersion;
+  private _v1TransactionConfig?: SolV1TransactionConfig;
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
@@ -53,6 +61,35 @@ export class ConfidentialTransferBuilder extends TransactionBuilder {
     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: SolTransactionVersion): this {
+    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: SolV1TransactionConfig): this {
+    this._v1TransactionConfig = config;
+    return this;
+  }
+
   /**
    * Override the zk-elgamal-proof program id.
    *
@@ -232,8 +269,79 @@ export class ConfidentialTransferBuilder extends TransactionBuilder {
   protected async buildImplementation(): Promise<Transaction> {
     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
+   */
+  private buildV1(): Transaction {
+    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');
+
+    const instructions: TransactionInstruction[] = [];
+    for (const instruction of this._ctInstructions) {
+      instructions.push(...solInstructionFactory(instruction, this._zkProofProgramId));
+    }
+
+    if (this._memo) {
+      const memoData: Memo = {
+        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 = compileV1Message({
+      instructions,
+      feePayer,
+      recentBlockhash: this._recentBlockhash,
+      transactionConfig: this._v1TransactionConfig,
+    });
+
+    const signatures: Uint8Array[] = [];
+    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 = serializeV1Transaction(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;
+  }
 }

modules/sdk-coin-sol/src/lib/transaction.ts

@@ -61,6 +61,8 @@ export class Transaction extends BaseTransaction {
   private _useTokenAddressTokenName = false;
   private _versionedTransaction: VersionedTransaction | undefined;
   private _versionedTransactionData: VersionedTransactionData | undefined;
+  private _v1TransactionBytes: Uint8Array | undefined;
+  private _v1MessageBytes: Uint8Array | undefined;
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
@@ -86,6 +88,9 @@ export class Transaction extends BaseTransaction {
 
   /** @inheritDoc */
   get signablePayload(): Buffer {
+    if (this._v1MessageBytes) {
+      return Buffer.from(this._v1MessageBytes);
+    }
     if (this._versionedTransaction) {
       return Buffer.from(this._versionedTransaction.message.serialize());
     }
@@ -95,6 +100,18 @@ export class Transaction extends BaseTransaction {
   /** @inheritDoc **/
   get id(): string {
     // Solana transaction ID === first signature: https://docs.solana.com/terminology#transaction-id
+    if (this._v1TransactionBytes) {
+      // v1 wire format: messageBytes followed by 64-byte signatures; the first signature is the tx id
+      const numRequired = this._v1TransactionBytes[1];
+      const sigStart = this._v1TransactionBytes.length - numRequired * 64;
+      if (numRequired > 0 && sigStart >= 0) {
+        const sig = this._v1TransactionBytes.slice(sigStart, sigStart + 64);
+        if (sig.some((byte) => byte !== 0)) {
+          return base58.encode(sig);
+        }
+      }
+    }
+
     if (this._versionedTransaction) {
       const sig = this._versionedTransaction.signatures?.[0];
       // Check if signature exists and is not a placeholder signature (all zeros)
@@ -181,7 +198,39 @@ export class Transaction extends BaseTransaction {
    * @returns {boolean} True if this is a VersionedTransaction
    */
   isVersionedTransaction(): boolean {
-    return !!this._versionedTransaction || !!this._versionedTransactionData;
+    return !!this._versionedTransaction || !!this._versionedTransactionData || !!this._v1TransactionBytes;
+  }
+
+  /**
+   * 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 {
+    return this._v1TransactionBytes;
+  }
+
+  /**
+   * 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) {
+    this._v1TransactionBytes = bytes;
+  }
+
+  /**
+   * 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 {
+    return this._v1MessageBytes;
+  }
+
+  /**
+   * 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) {
+    this._v1MessageBytes = bytes;
   }
 
   /**
@@ -257,6 +306,11 @@ export class Transaction extends BaseTransaction {
 
   /** @inheritdoc */
   toBroadcastFormat(): string {
+    if (this._v1TransactionBytes) {
+      // v1 wire format is message-first with signatures appended (no length prefix)
+      return Buffer.from(this._v1TransactionBytes).toString('base64');
+    }
+
     if (this._versionedTransaction) {
       // VersionedTransaction.serialize() doesn't need requireAllSignatures parameter
       // It automatically handles whatever signatures are present

modules/sdk-coin-sol/src/lib/transactionBuilder.ts

@@ -308,6 +308,15 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
     this._signatures.push({ publicKey, signature });
   }
 
+  /**
+   * Get the externally-added signatures (via addSignature) in order.
+   *
+   * @returns {Signature[]} The list of external signatures
+   */
+  protected getAdditionalSignatures(): Signature[] {
+    return this._signatures;
+  }
+
   /**
    * Sets the sender of this transaction.
    * This account will be responsible for paying transaction fees.

modules/sdk-coin-sol/src/sol.ts

@@ -222,6 +222,8 @@ export interface SolConsolidationRecoveryOptions extends MPCConsolidationRecover
 
 const HEX_REGEX = /^[0-9a-fA-F]+$/;
 const BLIND_SIGNING_TX_TYPES_TO_CHECK = { enabletoken: 'AssociatedTokenAccountInitialization' };
+// Maximum wire size of a v1 (SIMD-0296/0385) transaction in bytes.
+const V1_TRANSACTION_SIZE_LIMIT = 4096;
 
 /**
  * Get amount string corrected for architecture-specific endianness issues.
@@ -2141,7 +2143,21 @@ export class Sol extends BaseCoin {
   async broadcastTransaction({
     serializedSignedTransaction,
   }: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult> {
-    validateRawTransaction(serializedSignedTransaction, true, true);
+    const rawBytes = Buffer.from(serializedSignedTransaction, 'base64');
+    // v1 (SIMD-0296/0385) transactions start with the 0x81 version prefix; the legacy
+    // parser cannot deserialize them, so validate the v1 size limit directly instead.
+    const isV1 = rawBytes.length > 0 && rawBytes[0] === 0x81;
+
+    if (isV1) {
+      if (rawBytes.length > V1_TRANSACTION_SIZE_LIMIT) {
+        throw new Error(
+          `v1 transaction exceeds the ${V1_TRANSACTION_SIZE_LIMIT}-byte size limit: ${rawBytes.length} bytes`
+        );
+      }
+    } else {
+      validateRawTransaction(serializedSignedTransaction, true, true);
+    }
+
     const response = await this.getDataFromNode({
       payload: {
         id: '1',