feat(sdk-coin-sol): add Solana v1 CT transaction assembly

Bump @solana/web3.js to 1.99.0 and add @solana/kit 8.3.0. Extend the
shared SolVersionedTransactionData with optional version and
transactionConfig fields and mirror them through the express route
schemas. Add a pure-additive v1 message compiler and serializer module.

Refs: CHALO-1602

Author: bhavidhingra

modules/express/src/typedRoutes/api/v2/consolidateAccount.ts

@@ -195,6 +195,13 @@ export const ConsolidateAccountRequestBody = {
         numReadonlyUnsignedAccounts: t.number,
       }),
       recentBlockhash: t.string,
+      version: t.union([t.literal(0), t.literal(1)]),
+      transactionConfig: t.partial({
+        computeUnitLimit: t.union([t.number, t.null]),
+        heapSize: t.union([t.number, t.null]),
+        loadedAccountsDataSizeLimit: t.union([t.number, t.null]),
+        priorityFee: t.union([t.number, t.null]),
+      }),
     })
   ),
   /** Aptos custom transaction parameters for entry function calls */

modules/express/src/typedRoutes/api/v2/prebuildAndSignTransaction.ts

@@ -164,6 +164,19 @@ export const SolVersionedTransactionData = t.partial({
   messageHeader: SolMessageHeader,
   /** Recent blockhash */
   recentBlockhash: t.string,
+  /** Transaction version. Absent or 0 = v0 (existing), 1 = v1 */
+  version: t.union([t.literal(0), t.literal(1)]),
+  /** V1 transaction config. Required when version === 1 */
+  transactionConfig: t.partial({
+    /** Compute unit limit, or null if unset */
+    computeUnitLimit: t.union([t.number, t.null]),
+    /** Requested heap size, or null if unset */
+    heapSize: t.union([t.number, t.null]),
+    /** Loaded accounts data size limit, or null if unset */
+    loadedAccountsDataSizeLimit: t.union([t.number, t.null]),
+    /** Priority fee in total lamports, or null if unset */
+    priorityFee: t.union([t.number, t.null]),
+  }),
 });
 
 /**

modules/express/src/typedRoutes/api/v2/sendCoins.ts

@@ -318,6 +318,13 @@ export const SendCoinsRequestBody = {
         numReadonlyUnsignedAccounts: t.number,
       }),
       recentBlockhash: t.string,
+      version: t.union([t.literal(0), t.literal(1)]),
+      transactionConfig: t.partial({
+        computeUnitLimit: t.union([t.number, t.null]),
+        heapSize: t.union([t.number, t.null]),
+        loadedAccountsDataSizeLimit: t.union([t.number, t.null]),
+        priorityFee: t.union([t.number, t.null]),
+      }),
     })
   ),
 

modules/express/src/typedRoutes/api/v2/sendmany.ts

@@ -418,6 +418,13 @@ export const SendManyRequestBody = {
         numReadonlyUnsignedAccounts: t.number,
       }),
       recentBlockhash: t.string,
+      version: t.union([t.literal(0), t.literal(1)]),
+      transactionConfig: t.partial({
+        computeUnitLimit: t.union([t.number, t.null]),
+        heapSize: t.union([t.number, t.null]),
+        loadedAccountsDataSizeLimit: t.union([t.number, t.null]),
+        priorityFee: t.union([t.number, t.null]),
+      }),
     })
   ),
 

modules/express/src/typedRoutes/api/v2/walletAccelerateTx.ts

@@ -340,6 +340,13 @@ export const AccelerateTxRequestBody = {
         numReadonlyUnsignedAccounts: t.number,
       }),
       recentBlockhash: t.string,
+      version: t.union([t.literal(0), t.literal(1)]),
+      transactionConfig: t.partial({
+        computeUnitLimit: t.union([t.number, t.null]),
+        heapSize: t.union([t.number, t.null]),
+        loadedAccountsDataSizeLimit: t.union([t.number, t.null]),
+        priorityFee: t.union([t.number, t.null]),
+      }),
     })
   ),
 

modules/express/src/typedRoutes/api/v2/walletEnableTokens.ts

@@ -284,6 +284,13 @@ export const EnableTokensRequestBody = {
         numReadonlyUnsignedAccounts: t.number,
       }),
       recentBlockhash: t.string,
+      version: t.union([t.literal(0), t.literal(1)]),
+      transactionConfig: t.partial({
+        computeUnitLimit: t.union([t.number, t.null]),
+        heapSize: t.union([t.number, t.null]),
+        loadedAccountsDataSizeLimit: t.union([t.number, t.null]),
+        priorityFee: t.union([t.number, t.null]),
+      }),
     })
   ),
 

modules/express/test/unit/typedRoutes/prebuildAndSignTransaction.ts

@@ -1,7 +1,10 @@
 import * as assert from 'assert';
 import * as t from 'io-ts';
 import { TransactionRequest as TxRequestResponse } from '@bitgo/public-types';
-import { PrebuildAndSignTransactionParams } from '../../../src/typedRoutes/api/v2/prebuildAndSignTransaction';
+import {
+  PrebuildAndSignTransactionParams,
+  SolVersionedTransactionData,
+} from '../../../src/typedRoutes/api/v2/prebuildAndSignTransaction';
 import {
   FullySignedTransactionResponse,
   HalfSignedAccountTransactionResponse,
@@ -734,6 +737,59 @@ describe('PrebuildAndSignTransaction codec tests', function () {
     });
   });
 
+  describe('SolVersionedTransactionData codec validation', function () {
+    it('should validate v1 data with version and transactionConfig', function () {
+      const v1Data = {
+        versionedInstructions: [],
+        addressLookupTables: [],
+        staticAccountKeys: ['test'],
+        messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 0 },
+        recentBlockhash: 'test',
+        version: 1,
+        transactionConfig: {
+          computeUnitLimit: 200000,
+          heapSize: 32768,
+          loadedAccountsDataSizeLimit: 65536,
+          priorityFee: 5000,
+        },
+      };
+      const decoded = assertDecode(SolVersionedTransactionData, v1Data);
+      assert.deepStrictEqual(decoded.version, 1);
+      assert.deepStrictEqual(decoded.transactionConfig, v1Data.transactionConfig);
+    });
+
+    it('should validate v1 data with null config fields', function () {
+      const v1Data = {
+        versionedInstructions: [],
+        addressLookupTables: [],
+        staticAccountKeys: ['test'],
+        messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 0 },
+        recentBlockhash: 'test',
+        version: 1,
+        transactionConfig: {
+          computeUnitLimit: null,
+          heapSize: null,
+          loadedAccountsDataSizeLimit: null,
+          priorityFee: null,
+        },
+      };
+      const decoded = assertDecode(SolVersionedTransactionData, v1Data);
+      assert.deepStrictEqual(decoded.version, 1);
+    });
+
+    it('should validate existing v0 data without version fields', function () {
+      const v0Data = {
+        versionedInstructions: [],
+        addressLookupTables: [],
+        staticAccountKeys: ['test'],
+        messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 0 },
+        recentBlockhash: 'test',
+      };
+      const decoded = assertDecode(SolVersionedTransactionData, v0Data);
+      assert.strictEqual(decoded.version, undefined);
+    });
+  });
+
   describe('Response codec validation', function () {
     it('should validate FullySignedTransactionResponse', function () {
       const validResponse = {

modules/sdk-coin-sol/package.json

@@ -63,9 +63,10 @@
     "@bitgo/statics": "^59.18.0",
     "@bitgo/wasm-solana": "^2.6.0",
     "@solana/buffer-layout": "^4.0.1",
+    "@solana/kit": "8.3.0",
     "@solana/spl-stake-pool": "1.1.8",
     "@solana/spl-token": "0.4.9",
-    "@solana/web3.js": "1.92.1",
+    "@solana/web3.js": "1.99.0",
     "bignumber.js": "^9.0.0",
     "bs58": "^4.0.1",
     "lodash": "^4.18.0",

modules/sdk-coin-sol/src/lib/v1/compileV1Message.ts

@@ -0,0 +1,146 @@
+import { BuildTransactionError, SolV1TransactionConfig } from '@bitgo/sdk-core';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import {
+  AccountRole,
+  address,
+  appendTransactionMessageInstructions,
+  compileTransactionMessage,
+  createTransactionMessage,
+  getCompiledTransactionMessageEncoder,
+  pipe,
+  setTransactionMessageConfig,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  type Blockhash,
+  type V1TransactionConfig,
+} from '@solana/kit';
+
+const COMPUTE_BUDGET_PROGRAM_ID = 'ComputeBudget111111111111111111111111111111';
+const SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = 2;
+const SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR = 3;
+const MICRO_LAMPORTS_PER_LAMPORT = 1_000_000;
+
+function toKitInstruction(instruction: TransactionInstruction) {
+  return {
+    programAddress: address(instruction.programId.toBase58()),
+    accounts: instruction.keys.map((k) => ({
+      address: address(k.pubkey.toBase58()),
+      role: k.isSigner
+        ? k.isWritable
+          ? AccountRole.WRITABLE_SIGNER
+          : AccountRole.READONLY_SIGNER
+        : k.isWritable
+        ? AccountRole.WRITABLE
+        : AccountRole.READONLY,
+    })),
+    data: instruction.data,
+  };
+}
+
+function readU32LE(data: Uint8Array, offset: number): number {
+  return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24);
+}
+
+function readU64LE(data: Uint8Array, offset: number): number {
+  let value = 0;
+  for (let i = 0; i < 8; i++) {
+    value += Number(data[offset + i]) * Math.pow(2, 8 * i);
+  }
+  return value;
+}
+
+function stripComputeBudgetInstructions(
+  instructions: TransactionInstruction[],
+  transactionConfig: SolV1TransactionConfig
+): { instructions: TransactionInstruction[]; config: SolV1TransactionConfig } {
+  const filtered: TransactionInstruction[] = [];
+  const config: SolV1TransactionConfig = { ...transactionConfig };
+
+  for (const instruction of instructions) {
+    const isComputeBudget = instruction.programId.toBase58() === COMPUTE_BUDGET_PROGRAM_ID;
+    const discriminator = instruction.data?.[0];
+
+    if (isComputeBudget && discriminator === SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR) {
+      if (config.computeUnitLimit === null) {
+        config.computeUnitLimit = readU32LE(instruction.data, 1);
+      }
+      continue;
+    }
+
+    if (isComputeBudget && discriminator === SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR) {
+      if (config.priorityFee === null && config.computeUnitLimit !== null) {
+        const microLamports = readU64LE(instruction.data, 1);
+        config.priorityFee = Math.ceil((microLamports * config.computeUnitLimit) / MICRO_LAMPORTS_PER_LAMPORT);
+      }
+      continue;
+    }
+
+    filtered.push(instruction);
+  }
+
+  return { instructions: filtered, config };
+}
+
+function toKitV1Config(config: SolV1TransactionConfig): V1TransactionConfig {
+  const kitConfig: V1TransactionConfig = {};
+  if (config.computeUnitLimit !== null) {
+    kitConfig.computeUnitLimit = config.computeUnitLimit;
+  }
+  if (config.heapSize !== null) {
+    kitConfig.heapSize = config.heapSize;
+  }
+  if (config.loadedAccountsDataSizeLimit !== null) {
+    kitConfig.loadedAccountsDataSizeLimit = config.loadedAccountsDataSizeLimit;
+  }
+  if (config.priorityFee !== null) {
+    kitConfig.priorityFeeLamports = BigInt(config.priorityFee);
+  }
+  return kitConfig;
+}
+
+export function compileV1Message(args: {
+  instructions: TransactionInstruction[];
+  feePayer: PublicKey;
+  recentBlockhash: string;
+  transactionConfig: SolV1TransactionConfig;
+}): Uint8Array {
+  const { instructions, feePayer, recentBlockhash, transactionConfig } = args;
+
+  if (!instructions || instructions.length === 0) {
+    throw new BuildTransactionError('At least one instruction is required to compile a v1 transaction');
+  }
+  if (!transactionConfig) {
+    throw new BuildTransactionError('transactionConfig is required to compile a v1 transaction');
+  }
+
+  const { instructions: filteredInstructions, config } = stripComputeBudgetInstructions(
+    instructions,
+    transactionConfig
+  );
+  const kitInstructions = filteredInstructions.map(toKitInstruction);
+
+  const message = pipe(
+    createTransactionMessage({ version: 1 }),
+    (m) => setTransactionMessageFeePayer(address(feePayer.toBase58()), m),
+    // lastValidBlockHeight is metadata only: kit does not serialize it into the v1 wire bytes,
+    // and submission is handled by the caller directly, so a non-zero placeholder is not needed.
+    (m) =>
+      setTransactionMessageLifetimeUsingBlockhash(
+        { blockhash: recentBlockhash as Blockhash, lastValidBlockHeight: 0n },
+        m
+      ),
+    (m) => appendTransactionMessageInstructions(kitInstructions, m),
+    (m) => setTransactionMessageConfig(toKitV1Config(config), m)
+  );
+
+  let compiled;
+  try {
+    compiled = compileTransactionMessage(message);
+  } catch (e) {
+    throw new BuildTransactionError(
+      `Failed to compile v1 transaction message: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+
+  return new Uint8Array(getCompiledTransactionMessageEncoder().encode(compiled));
+}

modules/sdk-coin-sol/src/lib/v1/serializeV1Transaction.ts

@@ -0,0 +1,65 @@
+import { BuildTransactionError } from '@bitgo/sdk-core';
+
+const SIGNATURE_BYTE_LENGTH = 64;
+const V1_VERSION_PREFIX = 0x81;
+const V1_TRANSACTION_SIZE_LIMIT = 4096;
+
+/**
+ * Assemble the v1 wire format of a signed transaction.
+ *
+ * Unlike legacy and v0 transactions, where signatures are prefixed before the message, a v1
+ * transaction places the message first and appends the signatures at the tail with no length
+ * prefix; the signature count is derived from the message header's numRequiredSignatures.
+ *
+ * @param messageBytes - The serialized v1 message bytes (starting with the 0x81 version prefix)
+ * @param signatures - The ed25519 signatures over the message bytes, one per required signer
+ * @returns The full v1 wire transaction bytes
+ */
+export function serializeV1Transaction(messageBytes: Uint8Array, signatures: Uint8Array[]): Uint8Array {
+  if (!messageBytes || messageBytes.length === 0) {
+    throw new BuildTransactionError('messageBytes is required to serialize a v1 transaction');
+  }
+  if (!signatures || signatures.length === 0) {
+    throw new BuildTransactionError('At least one signature is required to serialize a v1 transaction');
+  }
+
+  for (const signature of signatures) {
+    if (signature.length !== SIGNATURE_BYTE_LENGTH) {
+      throw new BuildTransactionError(
+        `Invalid signature length: expected ${SIGNATURE_BYTE_LENGTH} bytes, got ${signature.length}`
+      );
+    }
+  }
+
+  if (messageBytes[0] !== V1_VERSION_PREFIX) {
+    throw new BuildTransactionError(
+      `Invalid v1 message: expected version prefix 0x${V1_VERSION_PREFIX.toString(
+        16
+      )}, got 0x${messageBytes[0].toString(16)}`
+    );
+  }
+
+  if (messageBytes[1] !== signatures.length) {
+    throw new BuildTransactionError(
+      `Signature count mismatch: message declares ${messageBytes[1]} required signers but ${signatures.length} were provided`
+    );
+  }
+
+  const totalLength = messageBytes.length + signatures.length * SIGNATURE_BYTE_LENGTH;
+  if (totalLength > V1_TRANSACTION_SIZE_LIMIT) {
+    throw new BuildTransactionError(
+      `v1 transaction exceeds the ${V1_TRANSACTION_SIZE_LIMIT}-byte size limit: ${totalLength} bytes`
+    );
+  }
+
+  const buffer = new Uint8Array(totalLength);
+  buffer.set(messageBytes, 0);
+
+  let offset = messageBytes.length;
+  for (const signature of signatures) {
+    buffer.set(signature, offset);
+    offset += SIGNATURE_BYTE_LENGTH;
+  }
+
+  return buffer;
+}