@utxopia/sdk 0.1.0-alpha.4 → 0.1.0-alpha.6

package/src/client.ts

@@ -56,7 +56,7 @@ import {
 import { selectUtxos, type UtxoDescriptor } from "./psbt";
 import { hexToBytes, bytesToHex, bigintToBytes } from "./crypto";
 import { EventClient } from "./event-client";
-import { type DepositOpReturnContext } from "./taproot";
+import { type DepositOpReturnContext, type BitcoinNetwork } from "./taproot";
 
 // ─── Types ──────────────────────────────────────────────────────────
 
@@ -269,8 +269,6 @@ export class UTXOpiaClient {
     const cached = this._tokenIdCache.get(mintAddress);
     if (cached !== undefined) return cached;
 
-    // Requires PublicKey — import dynamically to avoid hard dep
-    const mintBytes = hexToBytes(mintAddress.padStart(64, "0"));
     // If it's a base58 address, convert via PublicKey
     let bytes: Uint8Array;
     try {
@@ -284,7 +282,9 @@ export class UTXOpiaClient {
         bytes = new PublicKey(mintAddress).toBytes();
       }
     } catch {
-      bytes = mintBytes;
+      // Lazy on purpose: a base58 mint padded to 64 is not hex, so computing
+      // this eagerly threw before the branch above ever ran.
+      bytes = hexToBytes(mintAddress.padStart(64, "0"));
     }
 
     const tokenId = computeTokenId(bytes);
@@ -425,7 +425,7 @@ export class UTXOpiaClient {
     depositIndex: number;
     ikaXOnlyPubkey: Uint8Array;
     recipient?: StealthMetaAddress;
-    network?: "mainnet" | "testnet" | "regtest";
+    network?: BitcoinNetwork;
   }): Promise<TweakDepositResult> {
     if (!this._keys) {
       throw new Error("No keys (login first)");
@@ -457,7 +457,7 @@ export class UTXOpiaClient {
    */
   async prepareDeposit(opts: {
     recipient?: StealthMetaAddress;
-    network?: "mainnet" | "testnet" | "regtest";
+    network?: BitcoinNetwork;
     opReturnContext: DepositOpReturnContext;
   }): Promise<NonInteractiveDepositResult> {
     const meta = opts.recipient ?? this._stealthAddress;
@@ -631,7 +631,7 @@ export class UTXOpiaClient {
   }
 }
 
-function sdkBitcoinNetworkToAddressNetwork(network: NetworkConfig["bitcoinNetwork"]): "mainnet" | "testnet" | "regtest" {
+function sdkBitcoinNetworkToAddressNetwork(network: NetworkConfig["bitcoinNetwork"]): BitcoinNetwork {
   if (network === "mainnet") return "mainnet";
   if (network === "regtest") return "regtest";
   return "testnet";

package/src/config.ts

@@ -358,8 +358,11 @@ export const MAINNET_CONFIG: NetworkConfig = {
   bitcoinNetwork: "mainnet",
   esploraUrl: "https://mempool.space/api",
 
-  // Circuit CDN
-  circuitCdnUrl: "https://circuit.utxopia.com",
+  // Circuit CDN. Must carry the full versioned path: `resolveCircuitPath` turns a bare host
+  // into `<host>/circuits/groth16`, which is a DIFFERENT, stale build that still serves 200s
+  // for every shape with a different delta. Proofs built from it verify locally and are
+  // rejected on chain as "proof invalid".
+  circuitCdnUrl: "https://circuit.utxopia.com/circuits/v2/groth16",
 
   // Groth16 Verifier (placeholder)
   groth16VerifierProgramId: address("11111111111111111111111111111111"),

package/src/crypto-babyjub.ts

@@ -35,11 +35,6 @@ export const BABYJUB_D = 168696n;
 export const BABYJUB_ORDER =
   2736030358979909402780800718157159386076813972158567259200215660948447373041n;
 
-/**
- * Baby Jubjub cofactor
- */
-export const BABYJUB_COFACTOR = 8n;
-
 /**
  * Generator point (BASE8) - matches circomlib's BabyPbk() generator
  * This is the base point of the prime-order subgroup (cofactor-cleared).

package/src/crypto.ts

@@ -14,6 +14,7 @@
  */
 
 import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex as nobleBytesToHex, hexToBytes as nobleHexToBytes } from "@noble/hashes/utils.js";
 
 // =============================================================================
 // Field Constants
@@ -110,22 +111,15 @@ export function bytesToBigint(bytes: Uint8Array): bigint {
  * Convert hex string to Uint8Array
  */
 export function hexToBytes(hex: string): Uint8Array {
-  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = new Uint8Array(cleanHex.length / 2);
-  for (let i = 0; i < cleanHex.length; i += 2) {
-    bytes[i / 2] = parseInt(cleanHex.substr(i, 2), 16);
-  }
-  return bytes;
+  // The 0x prefix is ours; noble rejects it. Everything after is noble's, which
+  // also means malformed hex now throws instead of decoding to zero bytes.
+  return nobleHexToBytes(hex.startsWith("0x") ? hex.slice(2) : hex);
 }
 
 /**
  * Convert Uint8Array to hex string
  */
-export function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes)
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-}
+export const bytesToHex = nobleBytesToHex;
 
 // =============================================================================
 // Hashing Utilities
@@ -184,16 +178,3 @@ export function scalarFromBytes(bytes: Uint8Array): bigint {
   }
   return mod(result, BABYJUB_ORDER);
 }
-
-/**
- * Convert a bigint scalar to 32 bytes (big-endian)
- */
-export function scalarToBytes(scalar: bigint): Uint8Array {
-  const bytes = new Uint8Array(32);
-  let temp = mod(scalar, BABYJUB_ORDER);
-  for (let i = 31; i >= 0; i--) {
-    bytes[i] = Number(temp & 0xffn);
-    temp = temp >> 8n;
-  }
-  return bytes;
-}

package/src/index.ts

@@ -349,6 +349,10 @@ export {
   DEPOSIT_OP_RETURN_VERSION,
   DEPOSIT_POOL_TAG_SIZE,
   DEPOSIT_OP_RETURN_SIZE,
+  bech32Hrp,
+  networkForHrp,
+  p2trAddress,
+  type BitcoinNetwork,
   type DepositDestinationChain,
   type DepositBitcoinNetwork,
   type DepositOpReturnContext,
@@ -803,6 +807,7 @@ export {
   buildVkRegistryData,
   parseVkRegistry,
   assertVkRegistryForShape,
+  assertVkeyMatchesRegistry,
   isVkRegistryReady,
   type JoinSplitVkMaterial,
   type SnarkjsVkeyJson,

package/src/instructions.ts

@@ -2191,124 +2191,6 @@ export { hexToBytes, bytesToHex } from "./crypto";
 // Permissioned Pool Builders
 // =============================================================================
 
-// ---------------------------------------------------------------------------
-// initializePermissioned (disc=21)
-// ---------------------------------------------------------------------------
-
-/** initializePermissioned instruction options */
-export interface InitializePermissionedOptions {
-  /** PDA bump for pool state */
-  poolBump: number;
-  /** PDA bump for commitment tree */
-  treeBump: number;
-  /** Deposit fee in basis points (u16 LE) */
-  depositFeeBps: number;
-  /** Withdrawal fee in basis points (u16 LE) */
-  withdrawalFeeBps: number;
-  /** Auditor's Solana pubkey (32 bytes) */
-  auditor: Uint8Array;
-  /** Auditor's viewing public key (32 bytes) */
-  auditorViewingPubkey: Uint8Array;
-  /** Account addresses — same layout as initialize (disc=0) */
-  accounts: {
-    /** 0. pool_state (writable) */
-    poolState: Address;
-    /** 1. commitment_tree (writable) */
-    commitmentTree: Address;
-    /** 2. zkbtc_mint (writable) */
-    zkbtcMint: Address;
-    /** 3. pool_vault (writable) */
-    poolVault: Address;
-    /** 4. deposit_vault (writable) */
-    depositVault: Address;
-    /** 5. authority (signer, writable — pays for storage) */
-    authority: Address;
-    /** 6. system_program (readonly) */
-    systemProgram: Address;
-  };
-}
-
-/**
- * Build initializePermissioned instruction data (disc=21).
- *
- * Layout (after disc byte — same as initialize plus two 32-byte fields):
- *   pool_bump(1) + tree_bump(1) + deposit_fee_bps(2 LE) + withdrawal_fee_bps(2 LE)
- *   + auditor(32) + auditor_viewing_pubkey(32)
- *   = 70 bytes of payload; 71 bytes total with disc.
- */
-export function buildInitializePermissionedInstructionData(options: {
-  poolBump: number;
-  treeBump: number;
-  depositFeeBps: number;
-  withdrawalFeeBps: number;
-  auditor: Uint8Array;
-  auditorViewingPubkey: Uint8Array;
-}): Uint8Array {
-  if (options.auditor.length !== 32) {
-    throw new Error(`auditor must be 32 bytes, got ${options.auditor.length}`);
-  }
-  if (options.auditorViewingPubkey.length !== 32) {
-    throw new Error(`auditorViewingPubkey must be 32 bytes, got ${options.auditorViewingPubkey.length}`);
-  }
-
-  // disc(1) + pool_bump(1) + tree_bump(1) + deposit_fee_bps(2) + withdrawal_fee_bps(2) + auditor(32) + auditor_viewing_pubkey(32) = 71
-  const data = new Uint8Array(71);
-  const view = new DataView(data.buffer);
-  let offset = 0;
-
-  data[offset++] = PERMISSIONED_DISC.INITIALIZE_PERMISSIONED; // disc = 21
-  data[offset++] = options.poolBump;
-  data[offset++] = options.treeBump;
-  view.setUint16(offset, options.depositFeeBps, true); offset += 2;
-  view.setUint16(offset, options.withdrawalFeeBps, true); offset += 2;
-  data.set(options.auditor, offset); offset += 32;
-  data.set(options.auditorViewingPubkey, offset);
-
-  return data;
-}
-
-/**
- * Build a complete initializePermissioned instruction (disc=21).
- *
- * Initializes a pool in permissioned mode; deposits/shields require auditor co-signing.
- *
- * Accounts (identical to initialize, disc=0):
- * 0. pool_state          (writable)
- * 1. commitment_tree     (writable)
- * 2. zkbtc_mint          (writable)
- * 3. pool_vault          (writable)
- * 4. deposit_vault       (writable)
- * 5. authority           (writable signer)
- * 6. system_program      (readonly)
- */
-export function buildInitializePermissionedInstruction(
-  options: InitializePermissionedOptions,
-): Instruction {
-  const config = getConfig();
-  const data = buildInitializePermissionedInstructionData({
-    poolBump: options.poolBump,
-    treeBump: options.treeBump,
-    depositFeeBps: options.depositFeeBps,
-    withdrawalFeeBps: options.withdrawalFeeBps,
-    auditor: options.auditor,
-    auditorViewingPubkey: options.auditorViewingPubkey,
-  });
-
-  return {
-    programAddress: config.utxopiaProgramId,
-    accounts: [
-      { address: options.accounts.poolState,      role: AccountRole.WRITABLE },
-      { address: options.accounts.commitmentTree, role: AccountRole.WRITABLE },
-      { address: options.accounts.zkbtcMint,      role: AccountRole.WRITABLE },
-      { address: options.accounts.poolVault,      role: AccountRole.WRITABLE },
-      { address: options.accounts.depositVault,   role: AccountRole.WRITABLE },
-      { address: options.accounts.authority,      role: AccountRole.WRITABLE_SIGNER },
-      { address: options.accounts.systemProgram,  role: AccountRole.READONLY },
-    ],
-    data,
-  };
-}
-
 // ---------------------------------------------------------------------------
 // completeDepositPermissioned (disc=22)
 // ---------------------------------------------------------------------------
@@ -2681,102 +2563,6 @@ export function buildRegisterExitDestinationInstruction(options: {
   };
 }
 
-// ---------------------------------------------------------------------------
-// setAuditorFrozen (disc=28)
-// ---------------------------------------------------------------------------
-
-/** setAuditorFrozen instruction options */
-export interface SetAuditorFrozenOptions {
-  /** true = freeze the auditor role; false = un-freeze */
-  frozen: boolean;
-  accounts: {
-    /** 0. pool_state (writable) */
-    poolState: Address;
-    /** 1. auditor (signer) */
-    auditor: Address;
-  };
-}
-
-/**
- * Build setAuditorFrozen instruction data (disc=28).
- *
- * Layout: disc(1) + frozen(1)  — frozen byte: 0 = not frozen, 1 = frozen.
- */
-export function buildSetAuditorFrozenInstructionData(frozen: boolean): Uint8Array {
-  return new Uint8Array([INSTRUCTION.SET_AUDITOR_FROZEN, frozen ? 1 : 0]);
-}
-
-/**
- * Build a complete setAuditorFrozen instruction (disc=28).
- *
- * Accounts:
- * 0. pool_state (writable)
- * 1. auditor    (signer)
- */
-export function buildSetAuditorFrozenInstruction(options: SetAuditorFrozenOptions): Instruction {
-  const config = getConfig();
-  return {
-    programAddress: config.utxopiaProgramId,
-    accounts: [
-      { address: options.accounts.poolState, role: AccountRole.WRITABLE },
-      { address: options.accounts.auditor,   role: AccountRole.READONLY_SIGNER },
-    ],
-    data: buildSetAuditorFrozenInstructionData(options.frozen),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// setAuditorViewingPubkey (disc=29)
-// ---------------------------------------------------------------------------
-
-/** setAuditorViewingPubkey instruction options */
-export interface SetAuditorViewingPubkeyOptions {
-  /** New 32-byte viewing pubkey for the auditor */
-  viewingPubkey: Uint8Array;
-  accounts: {
-    /** 0. pool_state (writable) */
-    poolState: Address;
-    /** 1. auditor (signer) */
-    auditor: Address;
-  };
-}
-
-/**
- * Build setAuditorViewingPubkey instruction data (disc=29).
- *
- * Layout: disc(1) + viewing_pubkey(32) = 33 bytes.
- */
-export function buildSetAuditorViewingPubkeyInstructionData(viewingPubkey: Uint8Array): Uint8Array {
-  if (viewingPubkey.length !== 32) {
-    throw new Error(`viewingPubkey must be 32 bytes, got ${viewingPubkey.length}`);
-  }
-  const data = new Uint8Array(33);
-  data[0] = INSTRUCTION.SET_AUDITOR_VIEWING_PUBKEY;
-  data.set(viewingPubkey, 1);
-  return data;
-}
-
-/**
- * Build a complete setAuditorViewingPubkey instruction (disc=29).
- *
- * Accounts:
- * 0. pool_state (writable)
- * 1. auditor    (signer)
- */
-export function buildSetAuditorViewingPubkeyInstruction(
-  options: SetAuditorViewingPubkeyOptions,
-): Instruction {
-  const config = getConfig();
-  return {
-    programAddress: config.utxopiaProgramId,
-    accounts: [
-      { address: options.accounts.poolState, role: AccountRole.WRITABLE },
-      { address: options.accounts.auditor,   role: AccountRole.READONLY_SIGNER },
-    ],
-    data: buildSetAuditorViewingPubkeyInstructionData(options.viewingPubkey),
-  };
-}
-
 // ---------------------------------------------------------------------------
 // rotateAuditor (disc=35)
 // ---------------------------------------------------------------------------

package/src/poseidon.ts

@@ -164,12 +164,3 @@ export function computeTokenId(mintBytes: Uint8Array): bigint {
   const reduced = reduceToField(mintBytes);
   return poseidonHashSync([reduced, 0n]);
 }
-
-/**
- * Convenience: compute token_id from a Solana address string
- */
-export function computeTokenIdFromAddress(mintAddress: string): bigint {
-  // Base58 decode — import from @solana/kit if available, otherwise use raw bytes
-  // For now, caller should pass raw bytes via computeTokenId
-  throw new Error("Use computeTokenId(mintBytes) with raw pubkey bytes");
-}

package/src/prover/index.ts

@@ -9,11 +9,3 @@
 
 // Re-export everything from the web prover (default for browser/Node.js)
 export * from "./web";
-
-// Re-export types
-export type {
-  MerkleProofInput,
-  ProofData,
-  CircuitType,
-  JoinSplitProofInputs,
-} from "./web";

package/src/prover/web.ts

@@ -15,7 +15,7 @@ import {
   computeJoinSplitCommitmentSync,
   computeJoinSplitNullifierSync,
 } from "../poseidon";
-import { BN254_FIELD_PRIME } from "../crypto";
+import { BN254_FIELD_PRIME, bytesToHex } from "../crypto";
 import { TREE_DEPTH } from "../merkle";
 import { getConfig } from "../config";
 import { MAX_SAFE_JOINSPLIT_SIZE } from "../vk-registry";
@@ -60,13 +60,6 @@ export interface ProofData {
 
 export type CircuitType = `joinsplit_${number}x${number}`;
 
-/** Names of non-JoinSplit auxiliary circuits (selective disclosure). */
-export type AuxCircuitName =
-  | "ownership"
-  | "range_sum"
-  | "range_sum_4"
-  | "range_sum_16";
-
 // Environment detection
 const isBrowser = typeof window !== "undefined";
 const isNode = typeof process !== "undefined" && process.versions?.node;
@@ -74,6 +67,27 @@ const isNode = typeof process !== "undefined" && process.versions?.node;
 // Configurable circuit paths
 let circuitBasePath = isBrowser ? "/circuits/groth16" : "./circuits";
 
+/**
+ * Fetch a circuit's `*.vkey.json` from the same base path its zkey comes from.
+ *
+ * Deliberately reads `circuitBasePath` rather than taking a URL: the point of the check this
+ * feeds (`assertVkeyMatchesRegistry`) is that the vkey describes the artifacts actually being
+ * proved with, and a caller-supplied URL could describe a different build entirely.
+ */
+export async function fetchCircuitVkey(circuitType: CircuitType): Promise<unknown> {
+  const cached = vkeyCache.get(circuitType);
+  if (cached) return cached;
+
+  const url = `${circuitBasePath}/${circuitType}/${circuitType}.vkey.json`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Could not fetch circuit vkey ${url}: ${res.status} ${res.statusText}`);
+  }
+  const vkey = await res.json();
+  vkeyCache.set(circuitType, vkey);
+  return vkey;
+}
+
 /**
  * Set the base path for circuit artifacts
  */
@@ -81,17 +95,11 @@ export function setCircuitPath(path: string): void {
   if (path === circuitBasePath) return;
   circuitBasePath = path;
   circuitCache.clear();
+  vkeyCache.clear();
   artifactBytesCache.clear();
   artifactDownloadCache.clear();
 }
 
-/**
- * Get the current circuit base path
- */
-export function getCircuitPath(): string {
-  return circuitBasePath;
-}
-
 // Lazy-loaded snarkjs module
 let snarkjs: any = null;
 
@@ -101,6 +109,7 @@ interface CircuitArtifact {
 }
 
 const circuitCache = new Map<CircuitType, CircuitArtifact>();
+const vkeyCache = new Map<CircuitType, unknown>();
 let proverInitialized = false;
 
 /**
@@ -164,9 +173,6 @@ export function setCircuitArtifactDigests(digests: Record<string, string> | null
   artifactBytesCache.clear();
 }
 
-const toHex = (buf: ArrayBuffer) =>
-  Array.from(new Uint8Array(buf), (b) => b.toString(16).padStart(2, "0")).join("");
-
 async function verifyArtifactBytes(url: string, bytes: Uint8Array): Promise<void> {
   if (!artifactDigests) return;
   // Key by path-under-base so one manifest works across origins (local dev vs CDN).
@@ -177,8 +183,8 @@ async function verifyArtifactBytes(url: string, bytes: Uint8Array): Promise<void
         `Regenerate the artifact manifest so it covers every shape this origin serves.`,
     );
   }
-  const actual = toHex(
-    await crypto.subtle.digest("SHA-256", bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer),
+  const actual = bytesToHex(
+    new Uint8Array(await crypto.subtle.digest("SHA-256", bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer)),
   );
   if (actual !== artifactDigests[key]) {
     throw new Error(
@@ -717,55 +723,3 @@ export async function cleanup(): Promise<void> {
 // ==========================================================================
 // Solana Instruction Building (for Groth16 on-chain verification)
 // ==========================================================================
-
-/**
- * Groth16 verifier program ID (from current config)
- */
-export function getGroth16VerifierProgramId(): Address {
-  const config = getConfig();
-  return config.groth16VerifierProgramId;
-}
-
-/**
- * Build instruction data for Groth16 verification
- */
-export function buildVerifyInstructionData(
-  proof: Uint8Array,
-  publicSignals: string[],
-  vkHash: string
-): Uint8Array {
-  const piBytes = publicSignals.flatMap((pi) => {
-    const bytes = new Array(32).fill(0);
-    const bigint = BigInt(pi);
-    for (let i = 31; i >= 0; i--) {
-      bytes[i] = Number((bigint >> BigInt((31 - i) * 8)) & 0xFFn);
-    }
-    return bytes;
-  });
-
-  const cleanHex = vkHash.startsWith("0x") ? vkHash.slice(2) : vkHash;
-  const vkHashBytes = new Uint8Array(cleanHex.length / 2);
-  for (let i = 0; i < vkHashBytes.length; i++) {
-    vkHashBytes[i] = parseInt(cleanHex.substr(i * 2, 2), 16);
-  }
-
-  const totalSize = proof.length + 4 + piBytes.length + 32;
-  const data = new Uint8Array(totalSize);
-  let offset = 0;
-
-  data.set(proof, offset);
-  offset += proof.length;
-
-  const piCount = publicSignals.length;
-  data[offset++] = piCount & 0xff;
-  data[offset++] = (piCount >> 8) & 0xff;
-  data[offset++] = (piCount >> 16) & 0xff;
-  data[offset++] = (piCount >> 24) & 0xff;
-
-  data.set(new Uint8Array(piBytes), offset);
-  offset += piBytes.length;
-
-  data.set(vkHashBytes, offset);
-
-  return data;
-}

package/src/psbt.ts

@@ -12,7 +12,7 @@
 
 import * as btc from "@scure/btc-signer";
 import { hex } from "@scure/base";
-import { DEPOSIT_OP_RETURN_SIZE, createOpReturnScriptFromPayload } from "./taproot";
+import { DEPOSIT_OP_RETURN_SIZE, createOpReturnScriptFromPayload, bech32Hrp, type BitcoinNetwork } from "./taproot";
 
 // =============================================================================
 // Types
@@ -54,7 +54,7 @@ export interface BuildDepositPsbtParams {
   /** Fee rate in sats/vbyte */
   feeRate: number;
   /** Bitcoin network */
-  network?: "mainnet" | "testnet" | "signet";
+  network?: BitcoinNetwork;
 }
 
 /** Result of PSBT construction */
@@ -151,7 +151,12 @@ export function buildDepositPsbt(params: BuildDepositPsbtParams): BuildDepositPs
     throw new Error(`OP_RETURN payload must be ${DEPOSIT_OP_RETURN_SIZE} bytes, got ${opReturnPayload.length}`);
   }
 
-  const btcNetwork = network === "mainnet" ? btc.NETWORK : btc.TEST_NETWORK;
+  // Regtest shares testnet's version bytes but not its bech32 hrp, so folding it
+  // into TEST_NETWORK leaves every bcrt1 address undecodable.
+  const btcNetwork =
+    network === "mainnet"
+      ? btc.NETWORK
+      : { ...btc.TEST_NETWORK, bech32: bech32Hrp(network) };
 
   // Calculate total input value
   const totalInput = senderUtxos.reduce((sum, u) => sum + u.value, 0);

package/src/spend-doc.ts

@@ -18,6 +18,7 @@ import {
   createUnshieldBoundParams,
   type SolanaPrivacyDomainContext,
 } from "./bound-params";
+import { bytesToHex as hex } from "./crypto";
 
 export interface SpendDoc {
   mode: "transfer" | "unshield" | "redeem";
@@ -64,8 +65,6 @@ function fmt(raw: bigint, decimals: number): string {
   return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
 }
 
-const hex = (b: Uint8Array) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
-
 function sortedValues(v: bigint[]): string {
   return [...v].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)).join(",");
 }