@bitgo-beta/sdk-coin-sol 7.6.4-beta.702 → 7.6.4-beta.704

package/dist/esm/lib/serialization/codecs/v1/config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * v1 (SIMD-0296/0385) transaction config codec: bit mask + value encoding.
+ */
+export declare const PRIORITY_FEE_BITS = 3;
+export declare const COMPUTE_UNIT_LIMIT_BIT = 4;
+export declare const LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT = 8;
+export declare const HEAP_SIZE_BIT = 16;
+export type ConfigValue = {
+    kind: 'u32' | 'u64';
+    value: number | bigint;
+};
+export declare function encodeConfigMaskAndValues(config: {
+    computeUnitLimit: number | null;
+    heapSize: number | null;
+    loadedAccountsDataSizeLimit: number | null;
+    priorityFee: number | null;
+}): {
+    mask: number;
+    values: ConfigValue[];
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/esm/lib/serialization/codecs/v1/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/serialization/codecs/v1/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,eAAO,MAAM,iBAAiB,IAAO,CAAC;AACtC,eAAO,MAAM,sBAAsB,IAAQ,CAAC;AAC5C,eAAO,MAAM,mCAAmC,IAAS,CAAC;AAC1D,eAAO,MAAM,aAAa,KAAU,CAAC;AAErC,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAE1E,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAChD,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CAoB1C"}

package/dist/esm/lib/serialization/codecs/v1/config.js

@@ -0,0 +1,30 @@
+/**
+ * v1 (SIMD-0296/0385) transaction config codec: bit mask + value encoding.
+ */
+// Transaction config mask bits (mirror @solana/transaction-messages).
+export const PRIORITY_FEE_BITS = 0b11;
+export const COMPUTE_UNIT_LIMIT_BIT = 0b100;
+export const LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT = 0b1000;
+export const HEAP_SIZE_BIT = 0b10000;
+export function encodeConfigMaskAndValues(config) {
+    let mask = 0;
+    const values = [];
+    if (config.priorityFee !== null) {
+        mask |= PRIORITY_FEE_BITS;
+        values.push({ kind: 'u64', value: BigInt(config.priorityFee) });
+    }
+    if (config.computeUnitLimit !== null) {
+        mask |= COMPUTE_UNIT_LIMIT_BIT;
+        values.push({ kind: 'u32', value: config.computeUnitLimit });
+    }
+    if (config.loadedAccountsDataSizeLimit !== null) {
+        mask |= LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT;
+        values.push({ kind: 'u32', value: config.loadedAccountsDataSizeLimit });
+    }
+    if (config.heapSize !== null) {
+        mask |= HEAP_SIZE_BIT;
+        values.push({ kind: 'u32', value: config.heapSize });
+    }
+    return { mask, values };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/serialization/codecs/v1/instruction.d.ts

@@ -0,0 +1,14 @@
+/**
+ * v1 (SIMD-0296/0385) transaction instruction codec: header + payload encoding.
+ */
+export type CompiledInstruction = {
+    programAddressIndex: number;
+    accountIndices: number[];
+    data: Uint8Array;
+};
+/**
+ * Encode instruction headers (4 bytes each) then payloads for the given
+ * compiled instructions, appending to `buf`.
+ */
+export declare function encodeInstructions(buf: number[], instructions: CompiledInstruction[]): void;
+//# sourceMappingURL=instruction.d.ts.map

package/dist/esm/lib/serialization/codecs/v1/instruction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/serialization/codecs/v1/instruction.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,mBAAmB,GAAG;IAChC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AASF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,mBAAmB,EAAE,GAAG,IAAI,CAc3F"}

package/dist/esm/lib/serialization/codecs/v1/instruction.js

@@ -0,0 +1,29 @@
+/**
+ * v1 (SIMD-0296/0385) transaction instruction codec: header + payload encoding.
+ */
+function pushU8(buf, v) {
+    buf.push(v & 0xff);
+}
+function pushU16LE(buf, v) {
+    buf.push(v & 0xff, (v >>> 8) & 0xff);
+}
+/**
+ * Encode instruction headers (4 bytes each) then payloads for the given
+ * compiled instructions, appending to `buf`.
+ */
+export function encodeInstructions(buf, instructions) {
+    for (const instruction of instructions) {
+        pushU8(buf, instruction.programAddressIndex);
+        pushU8(buf, instruction.accountIndices.length);
+        pushU16LE(buf, instruction.data.length);
+    }
+    for (const instruction of instructions) {
+        for (const idx of instruction.accountIndices) {
+            pushU8(buf, idx);
+        }
+        for (const b of instruction.data) {
+            pushU8(buf, b);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/serialization/codecs/v1/message.d.ts

@@ -0,0 +1,17 @@
+import { encodeConfigMaskAndValues, ConfigValue } from './config';
+import { CompiledInstruction } from './instruction';
+export type V1MessageHeader = {
+    numSignerAccounts: number;
+    numReadonlySignerAccounts: number;
+    numReadonlyNonSignerAccounts: number;
+};
+export declare function encodeV1Message(args: {
+    header: V1MessageHeader;
+    configMask: number;
+    configValues: ConfigValue[];
+    blockhash: string;
+    staticAccounts: string[];
+    compiledInstructions: CompiledInstruction[];
+}): Uint8Array;
+export { encodeConfigMaskAndValues };
+//# sourceMappingURL=message.d.ts.map

package/dist/esm/lib/serialization/codecs/v1/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/serialization/codecs/v1/message.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,EAAsB,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAuBxE,MAAM,MAAM,eAAe,GAAG;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,yBAAyB,EAAE,MAAM,CAAC;IAClC,4BAA4B,EAAE,MAAM,CAAC;CACtC,CAAC;AAEF,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;CAC7C,GAAG,UAAU,CA+Bb;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/esm/lib/serialization/codecs/v1/message.js

@@ -0,0 +1,61 @@
+import bs58 from 'bs58';
+import { PublicKey } from '@solana/web3.js';
+import { BuildTransactionError } from '@bitgo-beta/sdk-core';
+import { encodeConfigMaskAndValues } from './config';
+import { encodeInstructions } from './instruction';
+/**
+ * v1 (SIMD-0296/0385) transaction message wire encoder.
+ *
+ * Layout: [version: 0x81][header: 3 x u8][configMask: u32 LE][blockhash: 32]
+ *   [numInstructions: u8][numStaticAccounts: u8]
+ *   [staticAccounts: 32 x n][configValues: per mask]
+ *   [instructionHeaders: 4 x n][instructionPayloads: per instruction]
+ */
+function pushU8(buf, v) {
+    buf.push(v & 0xff);
+}
+function pushU32LE(buf, v) {
+    buf.push(v & 0xff, (v >>> 8) & 0xff, (v >>> 16) & 0xff, (v >>> 24) & 0xff);
+}
+function pushU64LE(buf, v) {
+    for (let i = 0; i < 8; i++) {
+        buf.push(Number((v >> BigInt(8 * i)) & 0xffn));
+    }
+}
+export function encodeV1Message(args) {
+    const { header, configMask, configValues, blockhash, staticAccounts, compiledInstructions } = args;
+    let blockhashBytes;
+    try {
+        blockhashBytes = bs58.decode(blockhash);
+    }
+    catch {
+        throw new BuildTransactionError('Invalid recent blockhash');
+    }
+    if (blockhashBytes.length !== 32) {
+        throw new BuildTransactionError('Invalid recent blockhash');
+    }
+    const buf = [];
+    pushU8(buf, 0x81); // version
+    pushU8(buf, header.numSignerAccounts);
+    pushU8(buf, header.numReadonlySignerAccounts);
+    pushU8(buf, header.numReadonlyNonSignerAccounts);
+    pushU32LE(buf, configMask);
+    for (const b of blockhashBytes)
+        pushU8(buf, b);
+    pushU8(buf, compiledInstructions.length);
+    pushU8(buf, staticAccounts.length);
+    for (const account of staticAccounts) {
+        for (const b of new PublicKey(account).toBytes())
+            pushU8(buf, b);
+    }
+    for (const value of configValues) {
+        if (value.kind === 'u64')
+            pushU64LE(buf, value.value);
+        else
+            pushU32LE(buf, value.value);
+    }
+    encodeInstructions(buf, compiledInstructions);
+    return new Uint8Array(buf);
+}
+export { encodeConfigMaskAndValues };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/serialization/compileTransactionMessage.d.ts

@@ -0,0 +1,30 @@
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+/** Supported Solana transaction versions. Only 1 (SIMD-0296/0385) is implemented. */
+export type TransactionVersion = 0 | 1;
+/**
+ * Configuration for a v1 transaction, mirroring the shared sdk-core type.
+ * All values are optional (null = unset); priorityFee is total lamports.
+ */
+export interface TransactionConfig {
+    computeUnitLimit: number | null;
+    heapSize: number | null;
+    loadedAccountsDataSizeLimit: number | null;
+    priorityFee: number | null;
+}
+/**
+ * Compile a Solana transaction message and return its wire bytes.
+ *
+ * Version-aware: only `version: 1` (SIMD-0296/0385) is implemented; other
+ * versions throw a clear unsupported-version error until they are added.
+ *
+ * @param args - version, instructions, fee payer, recent blockhash, and config
+ * @returns the serialized message bytes (v1 starts with the 0x81 version prefix)
+ */
+export declare function compileTransactionMessage(args: {
+    version: TransactionVersion;
+    instructions: TransactionInstruction[];
+    feePayer: PublicKey;
+    recentBlockhash: string;
+    transactionConfig: TransactionConfig;
+}): Uint8Array;
+//# sourceMappingURL=compileTransactionMessage.d.ts.map

package/dist/esm/lib/serialization/compileTransactionMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileTransactionMessage.d.ts","sourceRoot":"","sources":["../../../../src/lib/serialization/compileTransactionMessage.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAKpE,qFAAqF;AACrF,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvC;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAoLD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,OAAO,EAAE,kBAAkB,CAAC;IAC5B,YAAY,EAAE,sBAAsB,EAAE,CAAC;IACvC,QAAQ,EAAE,SAAS,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,iBAAiB,CAAC;CACtC,GAAG,UAAU,CAqDb"}

package/dist/esm/lib/serialization/compileTransactionMessage.js

@@ -0,0 +1,202 @@
+import { BuildTransactionError } from '@bitgo-beta/sdk-core';
+import { encodeV1Message } from './codecs/v1/message';
+import { encodeConfigMaskAndValues } from './codecs/v1/config';
+// AccountRole bit values (mirror @solana/instructions).
+const READONLY = 0;
+const WRITABLE = 1;
+const READONLY_SIGNER = 2;
+const WRITABLE_SIGNER = 3;
+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 = 1000000;
+const MAX_ACCOUNTS = 64;
+const MAX_SIGNERS = 12;
+const MAX_INSTRUCTIONS = 64;
+const MAX_ACCOUNTS_PER_INSTRUCTION = 255;
+const isSigner = (role) => (role & READONLY_SIGNER) !== 0;
+const isWritable = (role) => (role & WRITABLE) !== 0;
+// Address ordering comparator matches @solana/addresses getAddressComparator.
+const addressComparator = new Intl.Collator('en', {
+    caseFirst: 'lower',
+    ignorePunctuation: false,
+    localeMatcher: 'best fit',
+    numeric: false,
+    sensitivity: 'variant',
+    usage: 'sort',
+}).compare;
+function readU32LE(data, offset) {
+    return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24);
+}
+function readU64LE(data, offset) {
+    let value = 0;
+    for (let i = 0; i < 8; i++) {
+        value += Number(data[offset + i]) * Math.pow(2, 8 * i);
+    }
+    return value;
+}
+/**
+ * Strip ComputeBudget instructions (SetComputeUnitLimit / SetComputeUnitPrice)
+ * and fold their values into the transaction config when still unset.
+ */
+function stripComputeBudgetInstructions(instructions, transactionConfig) {
+    const filtered = [];
+    const config = { ...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 };
+}
+/**
+ * Collect + order accounts exactly as @solana/transaction-messages does:
+ * fee payer first (WRITABLE_SIGNER), then static accounts sorted by
+ * (isSigner, isWritable, base58 collator). Duplicate addresses merge roles.
+ * Enforces the kit's invoked-program rules.
+ */
+function collectOrderedAccounts(feePayer, instructions) {
+    const feePayerAddress = feePayer.toBase58();
+    const map = new Map();
+    const metaByAddress = new Map();
+    const invokedPrograms = new Set();
+    map.set(feePayerAddress, WRITABLE_SIGNER);
+    metaByAddress.set(feePayerAddress, { address: feePayerAddress, role: WRITABLE_SIGNER });
+    const upsert = (address, role, isInvokedProgram) => {
+        if (address === feePayerAddress) {
+            if (isInvokedProgram) {
+                throw new BuildTransactionError(`Invoked program ${address} cannot pay fees`);
+            }
+        }
+        if (isInvokedProgram && isWritable(role)) {
+            throw new BuildTransactionError(`Invoked program ${address} must not be writable`);
+        }
+        const current = map.get(address);
+        if (current !== undefined) {
+            const merged = (current | role);
+            if (isInvokedProgram && isWritable(merged)) {
+                throw new BuildTransactionError(`Invoked program ${address} must not be writable`);
+            }
+            map.set(address, merged);
+            metaByAddress.set(address, { address, role: merged });
+        }
+        else {
+            map.set(address, role);
+            metaByAddress.set(address, { address, role });
+        }
+    };
+    for (const instruction of instructions) {
+        const programAddress = instruction.programId.toBase58();
+        invokedPrograms.add(programAddress);
+        upsert(programAddress, READONLY, true);
+        for (const key of instruction.keys) {
+            upsert(key.pubkey.toBase58(), key.isSigner ? (key.isWritable ? WRITABLE_SIGNER : READONLY_SIGNER) : key.isWritable ? WRITABLE : READONLY, invokedPrograms.has(key.pubkey.toBase58()));
+        }
+    }
+    const ordered = [...metaByAddress.values()];
+    ordered.sort((a, b) => {
+        const aFee = a.address === feePayerAddress ? -1 : 0;
+        const bFee = b.address === feePayerAddress ? -1 : 0;
+        if (aFee !== bFee)
+            return aFee - bFee;
+        const aSigner = isSigner(a.role) ? -1 : 0;
+        const bSigner = isSigner(b.role) ? -1 : 0;
+        if (aSigner !== bSigner)
+            return aSigner - bSigner;
+        const aWritable = isWritable(a.role) ? -1 : 0;
+        const bWritable = isWritable(b.role) ? -1 : 0;
+        if (aWritable !== bWritable)
+            return aWritable - bWritable;
+        return addressComparator(a.address, b.address);
+    });
+    return ordered;
+}
+function computeHeader(orderedAccounts) {
+    let numSignerAccounts = 0;
+    let numReadonlySignerAccounts = 0;
+    let numReadonlyNonSignerAccounts = 0;
+    for (const account of orderedAccounts) {
+        if (isSigner(account.role)) {
+            numSignerAccounts++;
+            if (!isWritable(account.role)) {
+                numReadonlySignerAccounts++;
+            }
+        }
+        else if (!isWritable(account.role)) {
+            numReadonlyNonSignerAccounts++;
+        }
+    }
+    return { numSignerAccounts, numReadonlySignerAccounts, numReadonlyNonSignerAccounts };
+}
+function compileInstructions(instructions, orderedAccounts) {
+    const accountIndex = new Map();
+    orderedAccounts.forEach((account, index) => accountIndex.set(account.address, index));
+    return instructions.map((instruction) => ({
+        programAddressIndex: accountIndex.get(instruction.programId.toBase58()),
+        accountIndices: instruction.keys.map((k) => accountIndex.get(k.pubkey.toBase58())),
+        data: instruction.data ?? new Uint8Array(),
+    }));
+}
+/**
+ * Compile a Solana transaction message and return its wire bytes.
+ *
+ * Version-aware: only `version: 1` (SIMD-0296/0385) is implemented; other
+ * versions throw a clear unsupported-version error until they are added.
+ *
+ * @param args - version, instructions, fee payer, recent blockhash, and config
+ * @returns the serialized message bytes (v1 starts with the 0x81 version prefix)
+ */
+export function compileTransactionMessage(args) {
+    const { version, instructions, feePayer, recentBlockhash, transactionConfig } = args;
+    if (version !== 1) {
+        throw new BuildTransactionError(`Unsupported transaction version: ${version}. Only version 1 is implemented.`);
+    }
+    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 orderedAccounts = collectOrderedAccounts(feePayer, filteredInstructions);
+    if (orderedAccounts.length > MAX_ACCOUNTS) {
+        throw new BuildTransactionError(`Too many accounts in v1 transaction: ${orderedAccounts.length} (max ${MAX_ACCOUNTS})`);
+    }
+    const numSigners = orderedAccounts.filter((a) => isSigner(a.role)).length;
+    if (numSigners > MAX_SIGNERS) {
+        throw new BuildTransactionError(`Too many signers in v1 transaction: ${numSigners} (max ${MAX_SIGNERS})`);
+    }
+    if (filteredInstructions.length > MAX_INSTRUCTIONS) {
+        throw new BuildTransactionError(`Too many instructions in v1 transaction: ${filteredInstructions.length} (max ${MAX_INSTRUCTIONS})`);
+    }
+    for (let i = 0; i < filteredInstructions.length; i++) {
+        if (filteredInstructions[i].keys.length > MAX_ACCOUNTS_PER_INSTRUCTION) {
+            throw new BuildTransactionError(`Too many accounts in instruction ${i}: ${filteredInstructions[i].keys.length} (max ${MAX_ACCOUNTS_PER_INSTRUCTION})`);
+        }
+    }
+    const header = computeHeader(orderedAccounts);
+    const { mask, values } = encodeConfigMaskAndValues(config);
+    const compiledInstructions = compileInstructions(filteredInstructions, orderedAccounts);
+    return encodeV1Message({
+        header,
+        configMask: mask,
+        configValues: values,
+        blockhash: recentBlockhash,
+        staticAccounts: orderedAccounts.map((account) => account.address),
+        compiledInstructions,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compileTransactionMessage.js","sourceRoot":"","sources":["../../../../src/lib/serialization/compileTransactionMessage.ts"],"names":[],"mappings":"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","sourcesContent":["import { BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { PublicKey, TransactionInstruction } from '@solana/web3.js';\nimport { encodeV1Message, V1MessageHeader } from './codecs/v1/message';\nimport { encodeConfigMaskAndValues } from './codecs/v1/config';\nimport { CompiledInstruction } from './codecs/v1/instruction';\n\n/** Supported Solana transaction versions. Only 1 (SIMD-0296/0385) is implemented. */\nexport type TransactionVersion = 0 | 1;\n\n/**\n * Configuration for a v1 transaction, mirroring the shared sdk-core type.\n * All values are optional (null = unset); priorityFee is total lamports.\n */\nexport interface TransactionConfig {\n  computeUnitLimit: number | null;\n  heapSize: number | null;\n  loadedAccountsDataSizeLimit: number | null;\n  priorityFee: number | null; // lamports (total)\n}\n\n// AccountRole bit values (mirror @solana/instructions).\nconst READONLY = 0;\nconst WRITABLE = 1;\nconst READONLY_SIGNER = 2;\nconst WRITABLE_SIGNER = 3;\n\nconst COMPUTE_BUDGET_PROGRAM_ID = 'ComputeBudget111111111111111111111111111111';\nconst SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = 2;\nconst SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR = 3;\nconst MICRO_LAMPORTS_PER_LAMPORT = 1_000_000;\n\nconst MAX_ACCOUNTS = 64;\nconst MAX_SIGNERS = 12;\nconst MAX_INSTRUCTIONS = 64;\nconst MAX_ACCOUNTS_PER_INSTRUCTION = 255;\n\nconst isSigner = (role: number): boolean => (role & READONLY_SIGNER) !== 0;\nconst isWritable = (role: number): boolean => (role & WRITABLE) !== 0;\n\n// Address ordering comparator matches @solana/addresses getAddressComparator.\nconst addressComparator = new Intl.Collator('en', {\n  caseFirst: 'lower',\n  ignorePunctuation: false,\n  localeMatcher: 'best fit',\n  numeric: false,\n  sensitivity: 'variant',\n  usage: 'sort',\n}).compare;\n\ntype AccountMeta = { address: string; role: number };\n\nfunction readU32LE(data: Uint8Array, offset: number): number {\n  return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24);\n}\n\nfunction readU64LE(data: Uint8Array, offset: number): number {\n  let value = 0;\n  for (let i = 0; i < 8; i++) {\n    value += Number(data[offset + i]) * Math.pow(2, 8 * i);\n  }\n  return value;\n}\n\n/**\n * Strip ComputeBudget instructions (SetComputeUnitLimit / SetComputeUnitPrice)\n * and fold their values into the transaction config when still unset.\n */\nfunction stripComputeBudgetInstructions(\n  instructions: TransactionInstruction[],\n  transactionConfig: TransactionConfig\n): { instructions: TransactionInstruction[]; config: TransactionConfig } {\n  const filtered: TransactionInstruction[] = [];\n  const config: TransactionConfig = { ...transactionConfig };\n\n  for (const instruction of instructions) {\n    const isComputeBudget = instruction.programId.toBase58() === COMPUTE_BUDGET_PROGRAM_ID;\n    const discriminator = instruction.data?.[0];\n\n    if (isComputeBudget && discriminator === SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR) {\n      if (config.computeUnitLimit === null) {\n        config.computeUnitLimit = readU32LE(instruction.data, 1);\n      }\n      continue;\n    }\n\n    if (isComputeBudget && discriminator === SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR) {\n      if (config.priorityFee === null && config.computeUnitLimit !== null) {\n        const microLamports = readU64LE(instruction.data, 1);\n        config.priorityFee = Math.ceil((microLamports * config.computeUnitLimit) / MICRO_LAMPORTS_PER_LAMPORT);\n      }\n      continue;\n    }\n\n    filtered.push(instruction);\n  }\n\n  return { instructions: filtered, config };\n}\n\n/**\n * Collect + order accounts exactly as @solana/transaction-messages does:\n * fee payer first (WRITABLE_SIGNER), then static accounts sorted by\n * (isSigner, isWritable, base58 collator). Duplicate addresses merge roles.\n * Enforces the kit's invoked-program rules.\n */\nfunction collectOrderedAccounts(feePayer: PublicKey, instructions: TransactionInstruction[]): AccountMeta[] {\n  const feePayerAddress = feePayer.toBase58();\n  const map = new Map<string, number>();\n  const metaByAddress = new Map<string, AccountMeta>();\n  const invokedPrograms = new Set<string>();\n\n  map.set(feePayerAddress, WRITABLE_SIGNER);\n  metaByAddress.set(feePayerAddress, { address: feePayerAddress, role: WRITABLE_SIGNER });\n\n  const upsert = (address: string, role: number, isInvokedProgram: boolean) => {\n    if (address === feePayerAddress) {\n      if (isInvokedProgram) {\n        throw new BuildTransactionError(`Invoked program ${address} cannot pay fees`);\n      }\n    }\n    if (isInvokedProgram && isWritable(role)) {\n      throw new BuildTransactionError(`Invoked program ${address} must not be writable`);\n    }\n    const current = map.get(address);\n    if (current !== undefined) {\n      const merged = (current | role) as number;\n      if (isInvokedProgram && isWritable(merged)) {\n        throw new BuildTransactionError(`Invoked program ${address} must not be writable`);\n      }\n      map.set(address, merged);\n      metaByAddress.set(address, { address, role: merged });\n    } else {\n      map.set(address, role);\n      metaByAddress.set(address, { address, role });\n    }\n  };\n\n  for (const instruction of instructions) {\n    const programAddress = instruction.programId.toBase58();\n    invokedPrograms.add(programAddress);\n    upsert(programAddress, READONLY, true);\n    for (const key of instruction.keys) {\n      upsert(\n        key.pubkey.toBase58(),\n        key.isSigner ? (key.isWritable ? WRITABLE_SIGNER : READONLY_SIGNER) : key.isWritable ? WRITABLE : READONLY,\n        invokedPrograms.has(key.pubkey.toBase58())\n      );\n    }\n  }\n\n  const ordered = [...metaByAddress.values()];\n  ordered.sort((a, b) => {\n    const aFee = a.address === feePayerAddress ? -1 : 0;\n    const bFee = b.address === feePayerAddress ? -1 : 0;\n    if (aFee !== bFee) return aFee - bFee;\n    const aSigner = isSigner(a.role) ? -1 : 0;\n    const bSigner = isSigner(b.role) ? -1 : 0;\n    if (aSigner !== bSigner) return aSigner - bSigner;\n    const aWritable = isWritable(a.role) ? -1 : 0;\n    const bWritable = isWritable(b.role) ? -1 : 0;\n    if (aWritable !== bWritable) return aWritable - bWritable;\n    return addressComparator(a.address, b.address);\n  });\n\n  return ordered;\n}\n\nfunction computeHeader(orderedAccounts: AccountMeta[]): V1MessageHeader {\n  let numSignerAccounts = 0;\n  let numReadonlySignerAccounts = 0;\n  let numReadonlyNonSignerAccounts = 0;\n  for (const account of orderedAccounts) {\n    if (isSigner(account.role)) {\n      numSignerAccounts++;\n      if (!isWritable(account.role)) {\n        numReadonlySignerAccounts++;\n      }\n    } else if (!isWritable(account.role)) {\n      numReadonlyNonSignerAccounts++;\n    }\n  }\n  return { numSignerAccounts, numReadonlySignerAccounts, numReadonlyNonSignerAccounts };\n}\n\nfunction compileInstructions(\n  instructions: TransactionInstruction[],\n  orderedAccounts: AccountMeta[]\n): CompiledInstruction[] {\n  const accountIndex = new Map<string, number>();\n  orderedAccounts.forEach((account, index) => accountIndex.set(account.address, index));\n\n  return instructions.map((instruction) => ({\n    programAddressIndex: accountIndex.get(instruction.programId.toBase58())!,\n    accountIndices: instruction.keys.map((k) => accountIndex.get(k.pubkey.toBase58())!),\n    data: instruction.data ?? new Uint8Array(),\n  }));\n}\n\n/**\n * Compile a Solana transaction message and return its wire bytes.\n *\n * Version-aware: only `version: 1` (SIMD-0296/0385) is implemented; other\n * versions throw a clear unsupported-version error until they are added.\n *\n * @param args - version, instructions, fee payer, recent blockhash, and config\n * @returns the serialized message bytes (v1 starts with the 0x81 version prefix)\n */\nexport function compileTransactionMessage(args: {\n  version: TransactionVersion;\n  instructions: TransactionInstruction[];\n  feePayer: PublicKey;\n  recentBlockhash: string;\n  transactionConfig: TransactionConfig;\n}): Uint8Array {\n  const { version, instructions, feePayer, recentBlockhash, transactionConfig } = args;\n\n  if (version !== 1) {\n    throw new BuildTransactionError(`Unsupported transaction version: ${version}. Only version 1 is implemented.`);\n  }\n  if (!instructions || instructions.length === 0) {\n    throw new BuildTransactionError('At least one instruction is required to compile a v1 transaction');\n  }\n  if (!transactionConfig) {\n    throw new BuildTransactionError('transactionConfig is required to compile a v1 transaction');\n  }\n\n  const { instructions: filteredInstructions, config } = stripComputeBudgetInstructions(\n    instructions,\n    transactionConfig\n  );\n\n  const orderedAccounts = collectOrderedAccounts(feePayer, filteredInstructions);\n  if (orderedAccounts.length > MAX_ACCOUNTS) {\n    throw new BuildTransactionError(\n      `Too many accounts in v1 transaction: ${orderedAccounts.length} (max ${MAX_ACCOUNTS})`\n    );\n  }\n  const numSigners = orderedAccounts.filter((a) => isSigner(a.role)).length;\n  if (numSigners > MAX_SIGNERS) {\n    throw new BuildTransactionError(`Too many signers in v1 transaction: ${numSigners} (max ${MAX_SIGNERS})`);\n  }\n  if (filteredInstructions.length > MAX_INSTRUCTIONS) {\n    throw new BuildTransactionError(\n      `Too many instructions in v1 transaction: ${filteredInstructions.length} (max ${MAX_INSTRUCTIONS})`\n    );\n  }\n  for (let i = 0; i < filteredInstructions.length; i++) {\n    if (filteredInstructions[i].keys.length > MAX_ACCOUNTS_PER_INSTRUCTION) {\n      throw new BuildTransactionError(\n        `Too many accounts in instruction ${i}: ${filteredInstructions[i].keys.length} (max ${MAX_ACCOUNTS_PER_INSTRUCTION})`\n      );\n    }\n  }\n\n  const header = computeHeader(orderedAccounts);\n  const { mask, values } = encodeConfigMaskAndValues(config);\n  const compiledInstructions = compileInstructions(filteredInstructions, orderedAccounts);\n\n  return encodeV1Message({\n    header,\n    configMask: mask,\n    configValues: values,\n    blockhash: recentBlockhash,\n    staticAccounts: orderedAccounts.map((account) => account.address),\n    compiledInstructions,\n  });\n}\n"]}

package/dist/esm/lib/serialization/wire-transaction.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 declare function serializeWireTransaction(messageBytes: Uint8Array, signatures: Uint8Array[]): Uint8Array;
+//# sourceMappingURL=wire-transaction.d.ts.map

package/dist/esm/lib/serialization/wire-transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire-transaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/serialization/wire-transaction.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,UAAU,CA+CvG"}

package/dist/esm/lib/serialization/wire-transaction.js

@@ -0,0 +1,48 @@
+import { BuildTransactionError } from '@bitgo-beta/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 serializeWireTransaction(messageBytes, signatures) {
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo-beta/sdk-coin-sol",
-  "version": "7.6.4-beta.702",
+  "version": "7.6.4-beta.704",
   "description": "BitGo SDK coin library for Sol",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/index.js",
@@ -56,10 +56,10 @@
     ]
   },
   "dependencies": {
-    "@bitgo-beta/logger": "1.0.1-beta.494",
-    "@bitgo-beta/sdk-core": "8.2.1-beta.2067",
-    "@bitgo-beta/sdk-lib-mpc": "8.2.0-beta.2076",
-    "@bitgo-beta/statics": "15.1.1-beta.2095",
+    "@bitgo-beta/logger": "1.0.1-beta.496",
+    "@bitgo-beta/sdk-core": "8.2.1-beta.2069",
+    "@bitgo-beta/sdk-lib-mpc": "8.2.0-beta.2078",
+    "@bitgo-beta/statics": "15.1.1-beta.2097",
     "@bitgo/public-types": "6.75.0",
     "@bitgo/wasm-solana": "^2.6.0",
     "@solana/buffer-layout": "^4.0.1",
@@ -73,11 +73,11 @@
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
-    "@bitgo-beta/sdk-api": "1.10.1-beta.2059",
+    "@bitgo-beta/sdk-api": "1.10.1-beta.2061",
     "@bitgo-beta/sdk-test": "^9.1.80",
     "@types/lodash": "^4.14.121"
   },
-  "gitHead": "75a1e9f973ce987e33ca2aaf5e5124e03739d035",
+  "gitHead": "17464c2623c873c1cb37dde34a7323876b49c76b",
   "files": [
     "dist/cjs",
     "dist/esm"