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

package/dist/esm/lib/scaledUiAmount.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2026 BitGo, Inc. All Rights Reserved.
+ */
+/**
+ * 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
+ */
+export declare function rawToUiAmountString(raw: bigint, multiplier: string, decimals: number): string;
+/**
+ * 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
+ */
+export declare function uiAmountToRaw(uiAmount: string, multiplier: string, decimals: number): bigint;
+//# sourceMappingURL=scaledUiAmount.d.ts.map

package/dist/esm/lib/scaledUiAmount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaledUiAmount.d.ts","sourceRoot":"","sources":["../../../src/lib/scaledUiAmount.ts"],"names":[],"mappings":"AAAA;;GAEG;AA2DH;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiC7F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmB5F"}

package/dist/esm/lib/scaledUiAmount.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright 2026 BitGo, Inc. All Rights Reserved.
+ */
+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
+ */
+export 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
+ */
+export 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/esm/lib/solInstructionFactory.d.ts

@@ -0,0 +1,10 @@
+import { TransactionInstruction } from '@solana/web3.js';
+import { InstructionParams } from './iface';
+/**
+ * Construct Solana instructions from instructions params
+ *
+ * @param {InstructionParams} instructionToBuild - the data containing the instruction params
+ * @returns {TransactionInstruction[]} An array containing supported Solana instructions
+ */
+export declare function solInstructionFactory(instructionToBuild: InstructionParams, zkProofProgramId?: string): TransactionInstruction[];
+//# sourceMappingURL=solInstructionFactory.d.ts.map

package/dist/esm/lib/solInstructionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solInstructionFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/solInstructionFactory.ts"],"names":[],"mappings":"AAeA,OAAO,EASL,sBAAsB,EAEvB,MAAM,iBAAiB,CAAC;AAYzB,OAAO,EAUL,iBAAiB,EAsBlB,MAAM,SAAS,CAAC;AAIjB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,kBAAkB,EAAE,iBAAiB,EACrC,gBAAgB,CAAC,EAAE,MAAM,GACxB,sBAAsB,EAAE,CA+D1B"}