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

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

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Copyright 2026 BitGo, Inc. All Rights Reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawToUiAmountString = rawToUiAmountString;
+exports.uiAmountToRaw = uiAmountToRaw;
+const DECIMAL_LITERAL_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/;
+/**
+ * Parse an exact decimal string into scaled-integer parts. Rejects scientific
+ * notation, empty strings, NaN/Infinity, and non-numeric input.
+ *
+ * @param value The decimal literal, e.g. "0.001"; "1e-9" must be written as "0.000000001"
+ */
+function parseDecimal(value, what) {
+    if (typeof value !== 'string' || !DECIMAL_LITERAL_PATTERN.test(value)) {
+        throw new Error(`Invalid ${what} '${value}': expected a finite decimal string`);
+    }
+    const negative = value.startsWith('-');
+    const unsigned = negative || value.startsWith('+') ? value.slice(1) : value;
+    const [intPart = '0', fracPart = ''] = unsigned.split('.');
+    const digits = BigInt(intPart + fracPart || '0');
+    return { negative, digits, scale: fracPart.length };
+}
+/** Render ±digits/10^scale as a normalized decimal string (no trailing zeros, no "-0"). */
+function toDecimalString({ negative, digits, scale }) {
+    if (digits === 0n) {
+        return '0';
+    }
+    let s = digits.toString().padStart(scale + 1, '0');
+    if (scale > 0) {
+        s = `${s.slice(0, -scale)}.${s.slice(-scale)}`;
+        s = s.replace(/0+$/, '').replace(/\.$/, '');
+    }
+    return negative ? `-${s}` : s;
+}
+/**
+ * Convert a raw base-unit amount to its scaled UI denomination.
+ *
+ * Exact by construction: the result is `raw * multiplier / 10^decimals`, whose
+ * exact decimal expansion never exceeds `multiplier scale + decimals` fraction
+ * digits, so no rounding ever occurs.
+ *
+ * @param raw Amount in raw base units (integer, >= 0)
+ * @param multiplier The mint's UiAmountMultiplier as a decimal string (> 0)
+ * @param decimals The mint's decimals (>= 0)
+ * @returns The exact UI amount as a decimal string
+ * @throws if any argument is malformed, the multiplier is not positive, or raw/decimals are negative
+ */
+function rawToUiAmountString(raw, multiplier, decimals) {
+    if (typeof raw !== 'bigint') {
+        throw new Error(`Invalid raw amount '${String(raw)}': expected a BigInt of base units`);
+    }
+    if (raw < 0n) {
+        throw new Error(`Invalid raw amount '${raw}': must be non-negative`);
+    }
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`Invalid decimals '${decimals}': must be a non-negative integer`);
+    }
+    const mult = parseDecimal(multiplier, 'multiplier');
+    if (mult.negative || mult.digits === 0n) {
+        throw new Error(`Invalid multiplier '${multiplier}': must be positive`);
+    }
+    // ui = raw * (multDigits / 10^multScale) / 10^decimals
+    //    = (raw * multDigits) / 10^(multScale + decimals)   — exact, terminating expansion
+    const numerator = raw * mult.digits;
+    const fractionDigits = mult.scale + decimals;
+    const denominator = 10n ** BigInt(fractionDigits);
+    const quotient = numerator / denominator;
+    const remainder = numerator % denominator;
+    if (remainder === 0n) {
+        return toDecimalString({ negative: false, digits: quotient, scale: 0 });
+    }
+    // The denominator IS 10^fractionDigits, so the exact fraction digits are `remainder`
+    // zero-padded to fractionDigits — no long division needed.
+    return toDecimalString({
+        negative: false,
+        digits: quotient * 10n ** BigInt(fractionDigits) + remainder,
+        scale: fractionDigits,
+    });
+}
+/**
+ * Convert a scaled UI denomination to raw base units. Inverse of
+ * {@link rawToUiAmountString}: flooring an exact ui string reproduces the
+ * original raw amount.
+ *
+ * @param uiAmount The UI amount as a decimal string (>= 0)
+ * @param multiplier The mint's UiAmountMultiplier as a decimal string (> 0)
+ * @param decimals The mint's decimals (>= 0)
+ * @returns The raw amount in base units, floored to the integer unit
+ * @throws if any argument is malformed, the ui amount is negative, or the multiplier is not positive
+ */
+function uiAmountToRaw(uiAmount, multiplier, decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`Invalid decimals '${decimals}': must be a non-negative integer`);
+    }
+    const ui = parseDecimal(uiAmount, 'uiAmount');
+    if (ui.negative) {
+        throw new Error(`Invalid uiAmount '${uiAmount}': must be non-negative`);
+    }
+    const mult = parseDecimal(multiplier, 'multiplier');
+    if (mult.negative || mult.digits === 0n) {
+        throw new Error(`Invalid multiplier '${multiplier}': must be positive`);
+    }
+    // ui = uiDigits / 10^uiScale;  multiplier = multDigits / 10^multScale
+    // raw = (uiDigits / 10^uiScale) * 10^decimals * (10^multScale / multDigits)
+    //     = (uiDigits * 10^(decimals + multScale)) / (multDigits * 10^uiScale)
+    const numerator = ui.digits * 10n ** BigInt(decimals + mult.scale);
+    const denominator = mult.digits * 10n ** BigInt(ui.scale);
+    return numerator / denominator; // floor — raw base units are integers
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scaledUiAmount.js","sourceRoot":"","sources":["../../../../src/lib/scaledUiAmount.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright 2026 BitGo, Inc. All Rights Reserved.\n */\n\n/**\n * Solana Token-2022 ScaledUiAmount conversion utilities (CSHLD-1688).\n *\n * A scaled-UI mint carries a `UiAmountMultiplier`. On-chain (and therefore in\n * every send/build path of this SDK) amounts are raw base units; the UI\n * denomination is `raw * multiplier / 10^decimals`, matching the SPL\n * token-2022 ScaledUiAmount extension semantics. These utilities exist for\n * display, reconciliation, and balance conversions only — they never feed\n * transaction building, which stays raw-denominated.\n *\n * All arithmetic is exact scaled-integer (BigInt) math — floats are never used,\n * so conversions are deterministic across runtimes and lose no precision:\n * `rawToUiAmountString` is always exact (the divisor is a power of ten, so the\n * exact expansion fits within `multiplierScale + decimals` fraction digits).\n * `uiAmountToRaw` floors to an integer number of base units and is the exact\n * inverse of `rawToUiAmountString` whenever the ui string is exact.\n */\n\n/** Significand and scale of a decimal literal: value = ±digits / 10^scale. */\ninterface ParsedDecimal {\n  negative: boolean;\n  digits: bigint;\n  scale: number;\n}\n\nconst DECIMAL_LITERAL_PATTERN = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$/;\n\n/**\n * Parse an exact decimal string into scaled-integer parts. Rejects scientific\n * notation, empty strings, NaN/Infinity, and non-numeric input.\n *\n * @param value The decimal literal, e.g. \"0.001\"; \"1e-9\" must be written as \"0.000000001\"\n */\nfunction parseDecimal(value: string, what: string): ParsedDecimal {\n  if (typeof value !== 'string' || !DECIMAL_LITERAL_PATTERN.test(value)) {\n    throw new Error(`Invalid ${what} '${value}': expected a finite decimal string`);\n  }\n  const negative = value.startsWith('-');\n  const unsigned = negative || value.startsWith('+') ? value.slice(1) : value;\n  const [intPart = '0', fracPart = ''] = unsigned.split('.');\n  const digits = BigInt(intPart + fracPart || '0');\n  return { negative, digits, scale: fracPart.length };\n}\n\n/** Render ±digits/10^scale as a normalized decimal string (no trailing zeros, no \"-0\"). */\nfunction toDecimalString({ negative, digits, scale }: ParsedDecimal): string {\n  if (digits === 0n) {\n    return '0';\n  }\n  let s = digits.toString().padStart(scale + 1, '0');\n  if (scale > 0) {\n    s = `${s.slice(0, -scale)}.${s.slice(-scale)}`;\n    s = s.replace(/0+$/, '').replace(/\\.$/, '');\n  }\n  return negative ? `-${s}` : s;\n}\n\n/**\n * Convert a raw base-unit amount to its scaled UI denomination.\n *\n * Exact by construction: the result is `raw * multiplier / 10^decimals`, whose\n * exact decimal expansion never exceeds `multiplier scale + decimals` fraction\n * digits, so no rounding ever occurs.\n *\n * @param raw Amount in raw base units (integer, >= 0)\n * @param multiplier The mint's UiAmountMultiplier as a decimal string (> 0)\n * @param decimals The mint's decimals (>= 0)\n * @returns The exact UI amount as a decimal string\n * @throws if any argument is malformed, the multiplier is not positive, or raw/decimals are negative\n */\nexport function rawToUiAmountString(raw: bigint, multiplier: string, decimals: number): string {\n  if (typeof raw !== 'bigint') {\n    throw new Error(`Invalid raw amount '${String(raw)}': expected a BigInt of base units`);\n  }\n  if (raw < 0n) {\n    throw new Error(`Invalid raw amount '${raw}': must be non-negative`);\n  }\n  if (!Number.isInteger(decimals) || decimals < 0) {\n    throw new Error(`Invalid decimals '${decimals}': must be a non-negative integer`);\n  }\n  const mult = parseDecimal(multiplier, 'multiplier');\n  if (mult.negative || mult.digits === 0n) {\n    throw new Error(`Invalid multiplier '${multiplier}': must be positive`);\n  }\n\n  // ui = raw * (multDigits / 10^multScale) / 10^decimals\n  //    = (raw * multDigits) / 10^(multScale + decimals)   — exact, terminating expansion\n  const numerator = raw * mult.digits;\n  const fractionDigits = mult.scale + decimals;\n  const denominator = 10n ** BigInt(fractionDigits);\n\n  const quotient = numerator / denominator;\n  const remainder = numerator % denominator;\n  if (remainder === 0n) {\n    return toDecimalString({ negative: false, digits: quotient, scale: 0 });\n  }\n  // The denominator IS 10^fractionDigits, so the exact fraction digits are `remainder`\n  // zero-padded to fractionDigits — no long division needed.\n  return toDecimalString({\n    negative: false,\n    digits: quotient * 10n ** BigInt(fractionDigits) + remainder,\n    scale: fractionDigits,\n  });\n}\n\n/**\n * Convert a scaled UI denomination to raw base units. Inverse of\n * {@link rawToUiAmountString}: flooring an exact ui string reproduces the\n * original raw amount.\n *\n * @param uiAmount The UI amount as a decimal string (>= 0)\n * @param multiplier The mint's UiAmountMultiplier as a decimal string (> 0)\n * @param decimals The mint's decimals (>= 0)\n * @returns The raw amount in base units, floored to the integer unit\n * @throws if any argument is malformed, the ui amount is negative, or the multiplier is not positive\n */\nexport function uiAmountToRaw(uiAmount: string, multiplier: string, decimals: number): bigint {\n  if (!Number.isInteger(decimals) || decimals < 0) {\n    throw new Error(`Invalid decimals '${decimals}': must be a non-negative integer`);\n  }\n  const ui = parseDecimal(uiAmount, 'uiAmount');\n  if (ui.negative) {\n    throw new Error(`Invalid uiAmount '${uiAmount}': must be non-negative`);\n  }\n  const mult = parseDecimal(multiplier, 'multiplier');\n  if (mult.negative || mult.digits === 0n) {\n    throw new Error(`Invalid multiplier '${multiplier}': must be positive`);\n  }\n\n  // ui = uiDigits / 10^uiScale;  multiplier = multDigits / 10^multScale\n  // raw = (uiDigits / 10^uiScale) * 10^decimals * (10^multScale / multDigits)\n  //     = (uiDigits * 10^(decimals + multScale)) / (multDigits * 10^uiScale)\n  const numerator = ui.digits * 10n ** BigInt(decimals + mult.scale);\n  const denominator = mult.digits * 10n ** BigInt(ui.scale);\n  return numerator / denominator; // floor — raw base units are integers\n}\n"]}

package/dist/cjs/src/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/cjs/src/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/cjs/src/lib/serialization/codecs/v1/config.js

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

package/dist/cjs/src/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/cjs/src/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/cjs/src/lib/serialization/codecs/v1/instruction.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * v1 (SIMD-0296/0385) transaction instruction codec: header + payload encoding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeInstructions = encodeInstructions;
+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`.
+ */
+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/cjs/src/lib/serialization/codecs/v1/message.d.ts

@@ -0,0 +1,27 @@
+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 };
+export type V1DecodedMessage = {
+    header: V1MessageHeader;
+    configMask: number;
+    configValues: ConfigValue[];
+    blockhash: string;
+    staticAccounts: string[];
+    compiledInstructions: CompiledInstruction[];
+    byteLength: number;
+};
+export declare function decodeV1Message(bytes: Uint8Array): V1DecodedMessage;
+//# sourceMappingURL=message.d.ts.map

package/dist/cjs/src/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,EACL,yBAAyB,EACzB,WAAW,EAKZ,MAAM,UAAU,CAAC;AAClB,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;AAUrC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,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;IAC5C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAyBF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,gBAAgB,CAwGnE"}

package/dist/cjs/src/lib/serialization/codecs/v1/message.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeConfigMaskAndValues = void 0;
+exports.encodeV1Message = encodeV1Message;
+exports.decodeV1Message = decodeV1Message;
+const bs58_1 = __importDefault(require("bs58"));
+const web3_js_1 = require("@solana/web3.js");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const config_1 = require("./config");
+Object.defineProperty(exports, "encodeConfigMaskAndValues", { enumerable: true, get: function () { return config_1.encodeConfigMaskAndValues; } });
+const instruction_1 = require("./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));
+    }
+}
+function encodeV1Message(args) {
+    const { header, configMask, configValues, blockhash, staticAccounts, compiledInstructions } = args;
+    let blockhashBytes;
+    try {
+        blockhashBytes = bs58_1.default.decode(blockhash);
+    }
+    catch {
+        throw new sdk_core_1.BuildTransactionError('Invalid recent blockhash');
+    }
+    if (blockhashBytes.length !== 32) {
+        throw new sdk_core_1.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 web3_js_1.PublicKey(account).toBytes())
+            pushU8(buf, b);
+    }
+    for (const value of configValues) {
+        if (value.kind === 'u64')
+            pushU64LE(buf, value.value);
+        else
+            pushU32LE(buf, value.value);
+    }
+    (0, instruction_1.encodeInstructions)(buf, compiledInstructions);
+    return new Uint8Array(buf);
+}
+const V1_VERSION_PREFIX = 0x81;
+const KNOWN_CONFIG_MASK = config_1.PRIORITY_FEE_BITS | config_1.COMPUTE_UNIT_LIMIT_BIT | config_1.LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT | config_1.HEAP_SIZE_BIT;
+const MAX_ACCOUNTS = 64;
+const MAX_INSTRUCTIONS = 64;
+const MAX_ACCOUNTS_PER_INSTRUCTION = 255;
+const STATIC_ACCOUNT_BYTES = 32;
+function readU8(b, o) {
+    return b[o];
+}
+function readU16LE(b, o) {
+    return b[o] | (b[o + 1] << 8);
+}
+function readU32LE(b, o) {
+    return (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)) >>> 0;
+}
+function readU64LE(b, o) {
+    let v = 0n;
+    for (let i = 0; i < 8; i++) {
+        v |= BigInt(b[o + i]) << BigInt(8 * i);
+    }
+    return v;
+}
+function ensureAvailable(b, off, size) {
+    if (off + size > b.length) {
+        throw new sdk_core_1.BuildTransactionError('Invalid v1 message: truncated');
+    }
+}
+function decodeV1Message(bytes) {
+    if (!bytes || bytes.length < 42) {
+        throw new sdk_core_1.BuildTransactionError('Invalid v1 message: too short');
+    }
+    let off = 0;
+    if (bytes[off++] !== V1_VERSION_PREFIX) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid v1 version prefix: 0x${bytes[0].toString(16)}`);
+    }
+    const numSignerAccounts = readU8(bytes, off++);
+    const numReadonlySignerAccounts = readU8(bytes, off++);
+    const numReadonlyNonSignerAccounts = readU8(bytes, off++);
+    const configMask = readU32LE(bytes, off);
+    off += 4;
+    if ((configMask & ~KNOWN_CONFIG_MASK) !== 0) {
+        throw new sdk_core_1.BuildTransactionError(`Unknown config mask bits: ${(configMask & ~KNOWN_CONFIG_MASK).toString(2)}`);
+    }
+    const blockhash = bs58_1.default.encode(bytes.slice(off, off + STATIC_ACCOUNT_BYTES));
+    off += STATIC_ACCOUNT_BYTES;
+    const numInstructions = readU8(bytes, off++);
+    const numStaticAccounts = readU8(bytes, off++);
+    if (numStaticAccounts > MAX_ACCOUNTS) {
+        throw new sdk_core_1.BuildTransactionError('Invalid v1 message: too many static accounts');
+    }
+    if (numInstructions > MAX_INSTRUCTIONS) {
+        throw new sdk_core_1.BuildTransactionError('Invalid v1 message: too many instructions');
+    }
+    if (numReadonlySignerAccounts > numSignerAccounts) {
+        throw new sdk_core_1.BuildTransactionError('Invalid v1 header: readonly signers exceed signers');
+    }
+    if (numSignerAccounts + numReadonlyNonSignerAccounts > numStaticAccounts) {
+        throw new sdk_core_1.BuildTransactionError('Invalid v1 header: signers + readonly non-signers exceed static accounts');
+    }
+    const staticAccounts = [];
+    for (let i = 0; i < numStaticAccounts; i++) {
+        ensureAvailable(bytes, off, STATIC_ACCOUNT_BYTES);
+        staticAccounts.push(bs58_1.default.encode(bytes.slice(off, off + STATIC_ACCOUNT_BYTES)));
+        off += STATIC_ACCOUNT_BYTES;
+    }
+    const configValues = [];
+    if (configMask & config_1.PRIORITY_FEE_BITS) {
+        ensureAvailable(bytes, off, 8);
+        configValues.push({ kind: 'u64', value: readU64LE(bytes, off) });
+        off += 8;
+    }
+    if (configMask & config_1.COMPUTE_UNIT_LIMIT_BIT) {
+        ensureAvailable(bytes, off, 4);
+        configValues.push({ kind: 'u32', value: readU32LE(bytes, off) });
+        off += 4;
+    }
+    if (configMask & config_1.LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT) {
+        ensureAvailable(bytes, off, 4);
+        configValues.push({ kind: 'u32', value: readU32LE(bytes, off) });
+        off += 4;
+    }
+    if (configMask & config_1.HEAP_SIZE_BIT) {
+        ensureAvailable(bytes, off, 4);
+        configValues.push({ kind: 'u32', value: readU32LE(bytes, off) });
+        off += 4;
+    }
+    const headers = [];
+    for (let i = 0; i < numInstructions; i++) {
+        ensureAvailable(bytes, off, 4);
+        const programAddressIndex = readU8(bytes, off++);
+        const accountCount = readU8(bytes, off++);
+        const dataLength = readU16LE(bytes, off);
+        off += 2;
+        if (programAddressIndex >= numStaticAccounts) {
+            throw new sdk_core_1.BuildTransactionError('Invalid v1 instruction: program index out of range');
+        }
+        if (accountCount > MAX_ACCOUNTS_PER_INSTRUCTION) {
+            throw new sdk_core_1.BuildTransactionError('Invalid v1 instruction: too many accounts');
+        }
+        headers.push({ programAddressIndex, accountCount, dataLength });
+    }
+    const compiledInstructions = [];
+    for (const h of headers) {
+        ensureAvailable(bytes, off, h.accountCount);
+        const accountIndices = [];
+        for (let i = 0; i < h.accountCount; i++) {
+            const idx = readU8(bytes, off++);
+            if (idx >= numStaticAccounts) {
+                throw new sdk_core_1.BuildTransactionError('Invalid v1 instruction: account index out of range');
+            }
+            accountIndices.push(idx);
+        }
+        ensureAvailable(bytes, off, h.dataLength);
+        const data = bytes.slice(off, off + h.dataLength);
+        off += h.dataLength;
+        compiledInstructions.push({ programAddressIndex: h.programAddressIndex, accountIndices, data });
+    }
+    return {
+        header: { numSignerAccounts, numReadonlySignerAccounts, numReadonlyNonSignerAccounts },
+        configMask,
+        configValues,
+        blockhash,
+        staticAccounts,
+        compiledInstructions,
+        byteLength: off,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.js","sourceRoot":"","sources":["../../../../../../../src/lib/serialization/codecs/v1/message.ts"],"names":[],"mappings":"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","sourcesContent":["import bs58 from 'bs58';\nimport { PublicKey } from '@solana/web3.js';\nimport { BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport {\n  encodeConfigMaskAndValues,\n  ConfigValue,\n  PRIORITY_FEE_BITS,\n  COMPUTE_UNIT_LIMIT_BIT,\n  LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT,\n  HEAP_SIZE_BIT,\n} from './config';\nimport { encodeInstructions, CompiledInstruction } from './instruction';\n\n/**\n * v1 (SIMD-0296/0385) transaction message wire encoder.\n *\n * Layout: [version: 0x81][header: 3 x u8][configMask: u32 LE][blockhash: 32]\n *   [numInstructions: u8][numStaticAccounts: u8]\n *   [staticAccounts: 32 x n][configValues: per mask]\n *   [instructionHeaders: 4 x n][instructionPayloads: per instruction]\n */\n\nfunction pushU8(buf: number[], v: number) {\n  buf.push(v & 0xff);\n}\nfunction pushU32LE(buf: number[], v: number) {\n  buf.push(v & 0xff, (v >>> 8) & 0xff, (v >>> 16) & 0xff, (v >>> 24) & 0xff);\n}\nfunction pushU64LE(buf: number[], v: bigint) {\n  for (let i = 0; i < 8; i++) {\n    buf.push(Number((v >> BigInt(8 * i)) & 0xffn));\n  }\n}\n\nexport type V1MessageHeader = {\n  numSignerAccounts: number;\n  numReadonlySignerAccounts: number;\n  numReadonlyNonSignerAccounts: number;\n};\n\nexport function encodeV1Message(args: {\n  header: V1MessageHeader;\n  configMask: number;\n  configValues: ConfigValue[];\n  blockhash: string;\n  staticAccounts: string[];\n  compiledInstructions: CompiledInstruction[];\n}): Uint8Array {\n  const { header, configMask, configValues, blockhash, staticAccounts, compiledInstructions } = args;\n\n  let blockhashBytes: Uint8Array;\n  try {\n    blockhashBytes = bs58.decode(blockhash);\n  } catch {\n    throw new BuildTransactionError('Invalid recent blockhash');\n  }\n  if (blockhashBytes.length !== 32) {\n    throw new BuildTransactionError('Invalid recent blockhash');\n  }\n\n  const buf: number[] = [];\n  pushU8(buf, 0x81); // version\n  pushU8(buf, header.numSignerAccounts);\n  pushU8(buf, header.numReadonlySignerAccounts);\n  pushU8(buf, header.numReadonlyNonSignerAccounts);\n  pushU32LE(buf, configMask);\n  for (const b of blockhashBytes) pushU8(buf, b);\n  pushU8(buf, compiledInstructions.length);\n  pushU8(buf, staticAccounts.length);\n  for (const account of staticAccounts) {\n    for (const b of new PublicKey(account).toBytes()) pushU8(buf, b);\n  }\n  for (const value of configValues) {\n    if (value.kind === 'u64') pushU64LE(buf, value.value as bigint);\n    else pushU32LE(buf, value.value as number);\n  }\n  encodeInstructions(buf, compiledInstructions);\n  return new Uint8Array(buf);\n}\n\nexport { encodeConfigMaskAndValues };\n\nconst V1_VERSION_PREFIX = 0x81;\nconst KNOWN_CONFIG_MASK =\n  PRIORITY_FEE_BITS | COMPUTE_UNIT_LIMIT_BIT | LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT | HEAP_SIZE_BIT;\nconst MAX_ACCOUNTS = 64;\nconst MAX_INSTRUCTIONS = 64;\nconst MAX_ACCOUNTS_PER_INSTRUCTION = 255;\nconst STATIC_ACCOUNT_BYTES = 32;\n\nexport type V1DecodedMessage = {\n  header: V1MessageHeader;\n  configMask: number;\n  configValues: ConfigValue[];\n  blockhash: string;\n  staticAccounts: string[];\n  compiledInstructions: CompiledInstruction[];\n  byteLength: number;\n};\n\nfunction readU8(b: Uint8Array, o: number): number {\n  return b[o];\n}\nfunction readU16LE(b: Uint8Array, o: number): number {\n  return b[o] | (b[o + 1] << 8);\n}\nfunction readU32LE(b: Uint8Array, o: number): number {\n  return (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)) >>> 0;\n}\nfunction readU64LE(b: Uint8Array, o: number): bigint {\n  let v = 0n;\n  for (let i = 0; i < 8; i++) {\n    v |= BigInt(b[o + i]) << BigInt(8 * i);\n  }\n  return v;\n}\n\nfunction ensureAvailable(b: Uint8Array, off: number, size: number): void {\n  if (off + size > b.length) {\n    throw new BuildTransactionError('Invalid v1 message: truncated');\n  }\n}\n\nexport function decodeV1Message(bytes: Uint8Array): V1DecodedMessage {\n  if (!bytes || bytes.length < 42) {\n    throw new BuildTransactionError('Invalid v1 message: too short');\n  }\n  let off = 0;\n  if (bytes[off++] !== V1_VERSION_PREFIX) {\n    throw new BuildTransactionError(`Invalid v1 version prefix: 0x${bytes[0].toString(16)}`);\n  }\n  const numSignerAccounts = readU8(bytes, off++);\n  const numReadonlySignerAccounts = readU8(bytes, off++);\n  const numReadonlyNonSignerAccounts = readU8(bytes, off++);\n  const configMask = readU32LE(bytes, off);\n  off += 4;\n  if ((configMask & ~KNOWN_CONFIG_MASK) !== 0) {\n    throw new BuildTransactionError(`Unknown config mask bits: ${(configMask & ~KNOWN_CONFIG_MASK).toString(2)}`);\n  }\n  const blockhash = bs58.encode(bytes.slice(off, off + STATIC_ACCOUNT_BYTES));\n  off += STATIC_ACCOUNT_BYTES;\n  const numInstructions = readU8(bytes, off++);\n  const numStaticAccounts = readU8(bytes, off++);\n  if (numStaticAccounts > MAX_ACCOUNTS) {\n    throw new BuildTransactionError('Invalid v1 message: too many static accounts');\n  }\n  if (numInstructions > MAX_INSTRUCTIONS) {\n    throw new BuildTransactionError('Invalid v1 message: too many instructions');\n  }\n  if (numReadonlySignerAccounts > numSignerAccounts) {\n    throw new BuildTransactionError('Invalid v1 header: readonly signers exceed signers');\n  }\n  if (numSignerAccounts + numReadonlyNonSignerAccounts > numStaticAccounts) {\n    throw new BuildTransactionError('Invalid v1 header: signers + readonly non-signers exceed static accounts');\n  }\n\n  const staticAccounts: string[] = [];\n  for (let i = 0; i < numStaticAccounts; i++) {\n    ensureAvailable(bytes, off, STATIC_ACCOUNT_BYTES);\n    staticAccounts.push(bs58.encode(bytes.slice(off, off + STATIC_ACCOUNT_BYTES)));\n    off += STATIC_ACCOUNT_BYTES;\n  }\n\n  const configValues: ConfigValue[] = [];\n  if (configMask & PRIORITY_FEE_BITS) {\n    ensureAvailable(bytes, off, 8);\n    configValues.push({ kind: 'u64', value: readU64LE(bytes, off) });\n    off += 8;\n  }\n  if (configMask & COMPUTE_UNIT_LIMIT_BIT) {\n    ensureAvailable(bytes, off, 4);\n    configValues.push({ kind: 'u32', value: readU32LE(bytes, off) });\n    off += 4;\n  }\n  if (configMask & LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT) {\n    ensureAvailable(bytes, off, 4);\n    configValues.push({ kind: 'u32', value: readU32LE(bytes, off) });\n    off += 4;\n  }\n  if (configMask & HEAP_SIZE_BIT) {\n    ensureAvailable(bytes, off, 4);\n    configValues.push({ kind: 'u32', value: readU32LE(bytes, off) });\n    off += 4;\n  }\n\n  const headers: Array<{ programAddressIndex: number; accountCount: number; dataLength: number }> = [];\n  for (let i = 0; i < numInstructions; i++) {\n    ensureAvailable(bytes, off, 4);\n    const programAddressIndex = readU8(bytes, off++);\n    const accountCount = readU8(bytes, off++);\n    const dataLength = readU16LE(bytes, off);\n    off += 2;\n    if (programAddressIndex >= numStaticAccounts) {\n      throw new BuildTransactionError('Invalid v1 instruction: program index out of range');\n    }\n    if (accountCount > MAX_ACCOUNTS_PER_INSTRUCTION) {\n      throw new BuildTransactionError('Invalid v1 instruction: too many accounts');\n    }\n    headers.push({ programAddressIndex, accountCount, dataLength });\n  }\n\n  const compiledInstructions: CompiledInstruction[] = [];\n  for (const h of headers) {\n    ensureAvailable(bytes, off, h.accountCount);\n    const accountIndices: number[] = [];\n    for (let i = 0; i < h.accountCount; i++) {\n      const idx = readU8(bytes, off++);\n      if (idx >= numStaticAccounts) {\n        throw new BuildTransactionError('Invalid v1 instruction: account index out of range');\n      }\n      accountIndices.push(idx);\n    }\n    ensureAvailable(bytes, off, h.dataLength);\n    const data = bytes.slice(off, off + h.dataLength);\n    off += h.dataLength;\n    compiledInstructions.push({ programAddressIndex: h.programAddressIndex, accountIndices, data });\n  }\n\n  return {\n    header: { numSignerAccounts, numReadonlySignerAccounts, numReadonlyNonSignerAccounts },\n    configMask,\n    configValues,\n    blockhash,\n    staticAccounts,\n    compiledInstructions,\n    byteLength: off,\n  };\n}\n"]}

package/dist/cjs/src/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/cjs/src/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"}