@forgezero/runtime 0.1.14 → 0.1.16

package/dist/finance/commission.js

@@ -1,423 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/finance/money.ts
-class MoneyError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "MoneyError";
-  }
-}
-var ASSETS = [
-  { code: "USDT", decimals: 6 },
-  { code: "USDC", decimals: 6 },
-  { code: "BTC", decimals: 8 },
-  { code: "ETH", decimals: 18 },
-  { code: "BNB", decimals: 18 },
-  { code: "EUR", decimals: 2 },
-  { code: "USD", decimals: 2 }
-];
-var REGISTRY = new Map(ASSETS.map((asset) => [asset.code, asset]));
-function defineAsset(spec) {
-  if (spec.decimals < 0 || spec.decimals > 30 || !Number.isInteger(spec.decimals)) {
-    throw new MoneyError("UNKNOWN_ASSET", `${spec.code}: decimals must be an integer 0–30.`);
-  }
-  REGISTRY.set(spec.code, spec);
-}
-function assetSpec(code) {
-  const spec = REGISTRY.get(code);
-  if (!spec)
-    throw new MoneyError("UNKNOWN_ASSET", `Unknown asset "${code}". Call defineAsset first.`);
-  return spec;
-}
-var money = (units, asset) => {
-  assetSpec(asset);
-  return { units, asset };
-};
-var zero = (asset) => money(0n, asset);
-function parseAmount(value, asset) {
-  const spec = assetSpec(asset);
-  const text = value.trim();
-  if (!/^-?\d+(\.\d+)?$/.test(text)) {
-    throw new MoneyError("NOT_FINITE", `"${value}" is not a plain decimal amount.`);
-  }
-  const negative = text.startsWith("-");
-  const [whole, fraction = ""] = text.replace("-", "").split(".");
-  if (fraction.length > spec.decimals) {
-    throw new MoneyError("PRECISION_LOSS", `${asset} has ${spec.decimals} decimals; "${value}" has ${fraction.length}.`);
-  }
-  const padded = fraction.padEnd(spec.decimals, "0");
-  const units = BigInt(whole + padded);
-  return { units: negative ? -units : units, asset };
-}
-function formatAmount(amount, options = {}) {
-  const spec = assetSpec(amount.asset);
-  const negative = amount.units < 0n;
-  const digits = (negative ? -amount.units : amount.units).toString().padStart(spec.decimals + 1, "0");
-  const whole = digits.slice(0, digits.length - spec.decimals);
-  let fraction = spec.decimals === 0 ? "" : digits.slice(digits.length - spec.decimals);
-  if (options.trim && fraction)
-    fraction = fraction.replace(/0+$/, "");
-  return `${negative ? "-" : ""}${whole}${fraction ? `.${fraction}` : ""}`;
-}
-function sameAsset(a, b) {
-  if (a.asset !== b.asset) {
-    throw new MoneyError("ASSET_MISMATCH", `Cannot combine ${a.asset} and ${b.asset}.`);
-  }
-}
-function add(a, b) {
-  sameAsset(a, b);
-  return { units: a.units + b.units, asset: a.asset };
-}
-function subtract(a, b) {
-  sameAsset(a, b);
-  return { units: a.units - b.units, asset: a.asset };
-}
-var negate = (amount) => ({ units: -amount.units, asset: amount.asset });
-var abs = (amount) => ({
-  units: amount.units < 0n ? -amount.units : amount.units,
-  asset: amount.asset
-});
-var isZero = (amount) => amount.units === 0n;
-var isNegative = (amount) => amount.units < 0n;
-function compare(a, b) {
-  sameAsset(a, b);
-  return a.units < b.units ? -1 : a.units > b.units ? 1 : 0;
-}
-var equals = (a, b) => a.asset === b.asset && a.units === b.units;
-var ROUNDING = ["down", "up", "half-up"];
-function divideRounded(numerator, denominator, mode) {
-  if (denominator === 0n)
-    throw new MoneyError("DIVIDE_BY_ZERO", "Division by zero.");
-  const negative = numerator < 0n !== denominator < 0n;
-  const a = numerator < 0n ? -numerator : numerator;
-  const b = denominator < 0n ? -denominator : denominator;
-  const quotient = a / b;
-  const remainder = a % b;
-  if (remainder === 0n)
-    return negative ? -quotient : quotient;
-  let result = quotient;
-  if (mode === "up")
-    result += 1n;
-  else if (mode === "half-up" && remainder * 2n >= b)
-    result += 1n;
-  return negative ? -result : result;
-}
-function mulRate(amount, rate, mode = "down") {
-  if (!/^-?\d+(\.\d+)?$/.test(rate.trim())) {
-    throw new MoneyError("NOT_FINITE", `"${rate}" is not a plain decimal rate.`);
-  }
-  const [whole, fraction = ""] = rate.trim().replace("-", "").split(".");
-  const scale = 10n ** BigInt(fraction.length);
-  const scaled = BigInt(whole + fraction) * (rate.trim().startsWith("-") ? -1n : 1n);
-  return { units: divideRounded(amount.units * scaled, scale, mode), asset: amount.asset };
-}
-function convert(amount, to, rate, mode = "down") {
-  const from = assetSpec(amount.asset);
-  const target = assetSpec(to);
-  const asTarget = mulRate({ units: amount.units, asset: to }, rate, mode);
-  const shift = target.decimals - from.decimals;
-  if (shift === 0)
-    return asTarget;
-  if (shift > 0)
-    return { units: asTarget.units * 10n ** BigInt(shift), asset: to };
-  return { units: divideRounded(asTarget.units, 10n ** BigInt(-shift), mode), asset: to };
-}
-function allocate(amount, parts) {
-  if (parts < 1)
-    throw new MoneyError("NOT_FINITE", "Cannot allocate into fewer than one part.");
-  const each = divideRounded(amount.units, BigInt(parts), "down");
-  const allocated = Array.from({ length: parts }, () => each);
-  let remainder = amount.units - each * BigInt(parts);
-  const step = remainder < 0n ? -1n : 1n;
-  for (let index = 0;remainder !== 0n; index = (index + 1) % parts) {
-    allocated[index] += step;
-    remainder -= step;
-  }
-  return allocated.map((units) => ({ units, asset: amount.asset }));
-}
-function toStep(amount, step, mode = "down") {
-  const stepUnits = parseAmount(step, amount.asset).units;
-  if (stepUnits <= 0n)
-    throw new MoneyError("NOT_FINITE", "A step must be positive.");
-  return { units: divideRounded(amount.units, stepUnits, mode) * stepUnits, asset: amount.asset };
-}
-var VERSION = "0.1.0";
-
-// src/finance/ledger.ts
-class LedgerError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "LedgerError";
-  }
-}
-var BUCKETS = ["available", "held"];
-var ACCOUNT_KINDS = ["user", "platform", "external"];
-var accountId = (account) => `${account.kind}:${account.owner}:${account.bucket ?? "available"}`;
-function parseAccount(id) {
-  const [kind, owner, bucket] = id.split(":");
-  return { kind, owner, bucket };
-}
-var queueKeyFor = (account) => `${account.kind}:${account.owner}`;
-var MAX_LEDGER_ENTRIES = 64;
-function assertBalanced(transaction) {
-  if (transaction.entries.length < 2) {
-    throw new LedgerError("EMPTY_TRANSACTION", "A transaction needs at least two entries.");
-  }
-  if (transaction.entries.length > MAX_LEDGER_ENTRIES) {
-    throw new LedgerError("TOO_MANY_ENTRIES", `A transaction may contain at most ${MAX_LEDGER_ENTRIES} entries; split this batch into separate transactions.`);
-  }
-  const totals = new Map;
-  for (const entry of transaction.entries) {
-    if (entry.amount.units === 0n) {
-      throw new LedgerError("ZERO_ENTRY", `An entry on ${accountId(entry.account)} moves nothing. Remove it or give it an amount.`);
-    }
-    totals.set(entry.amount.asset, (totals.get(entry.amount.asset) ?? 0n) + entry.amount.units);
-  }
-  for (const [asset, total] of totals) {
-    if (total !== 0n) {
-      throw new LedgerError("UNBALANCED", `${asset} does not sum to zero — it is off by ${total} minor units. Every movement needs a counterparty.`);
-    }
-  }
-}
-function transfer(args) {
-  const transaction = {
-    reference: args.reference,
-    kind: args.kind,
-    atMs: args.atMs,
-    memo: args.memo,
-    entries: [
-      { account: args.from, amount: { units: -args.amount.units, asset: args.amount.asset } },
-      { account: args.to, amount: args.amount }
-    ]
-  };
-  assertBalanced(transaction);
-  return transaction;
-}
-var placeHold = (args) => transfer({
-  reference: args.reference,
-  kind: "hold.place",
-  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "available" },
-  to: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
-  amount: args.amount,
-  atMs: args.atMs,
-  memo: args.memo
-});
-var releaseHold = (args) => transfer({
-  reference: args.reference,
-  kind: "hold.release",
-  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
-  to: { kind: args.kind ?? "user", owner: args.owner, bucket: "available" },
-  amount: args.amount,
-  atMs: args.atMs
-});
-var captureHold = (args) => transfer({
-  reference: args.reference,
-  kind: "hold.capture",
-  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
-  to: args.to,
-  amount: args.amount,
-  atMs: args.atMs,
-  memo: args.memo
-});
-function balancesFrom(transactions) {
-  const balances = new Map;
-  for (const transaction of transactions) {
-    for (const entry of transaction.entries) {
-      const id = accountId(entry.account);
-      const perAsset = balances.get(id) ?? new Map;
-      const current = perAsset.get(entry.amount.asset) ?? zero(entry.amount.asset);
-      perAsset.set(entry.amount.asset, add(current, entry.amount));
-      balances.set(id, perAsset);
-    }
-  }
-  return balances;
-}
-function balanceOf(balances, account, asset) {
-  return balances.get(accountId(account))?.get(asset) ?? zero(asset);
-}
-var availableOf = (balances, owner, asset, kind = "user") => balanceOf(balances, { kind, owner, bucket: "available" }, asset);
-var heldOf = (balances, owner, asset, kind = "user") => balanceOf(balances, { kind, owner, bucket: "held" }, asset);
-var totalOf = (balances, owner, asset, kind = "user") => add(availableOf(balances, owner, asset, kind), heldOf(balances, owner, asset, kind));
-function trialBalance(transactions) {
-  const totals = new Map;
-  const accounts = new Map;
-  for (const transaction of transactions) {
-    for (const entry of transaction.entries) {
-      totals.set(entry.amount.asset, (totals.get(entry.amount.asset) ?? 0n) + entry.amount.units);
-      const seen = accounts.get(entry.amount.asset) ?? new Set;
-      seen.add(accountId(entry.account));
-      accounts.set(entry.amount.asset, seen);
-    }
-  }
-  const perAsset = [...totals.entries()].map(([asset, total]) => ({
-    asset,
-    total,
-    accounts: accounts.get(asset)?.size ?? 0
-  }));
-  const discrepancies = perAsset.filter((row) => row.total !== 0n).map((row) => ({ asset: row.asset, off: row.total }));
-  return { ok: discrepancies.length === 0, perAsset, discrepancies };
-}
-function statement(transactions, account, asset) {
-  const id = accountId(account);
-  let running = zero(asset);
-  return [...transactions].sort((a, b) => a.atMs - b.atMs).flatMap((transaction) => transaction.entries.filter((entry) => accountId(entry.account) === id && entry.amount.asset === asset).map((entry) => {
-    running = add(running, entry.amount);
-    return {
-      atMs: transaction.atMs,
-      reference: transaction.reference,
-      kind: transaction.kind,
-      amount: formatAmount(entry.amount, { trim: true }),
-      balance: formatAmount(running, { trim: true })
-    };
-  }));
-}
-function assertAvailable(balances, args) {
-  const available = availableOf(balances, args.owner, args.amount.asset, args.kind ?? "user");
-  if (subtract(available, args.amount).units < 0n) {
-    throw new LedgerError("INSUFFICIENT_AVAILABLE", `${args.owner} has ${formatAmount(available, { trim: true })} ${args.amount.asset} available; this needs ${formatAmount(args.amount, { trim: true })}.`);
-  }
-}
-var VERSION2 = "0.1.0";
-
-// src/finance/commission.ts
-class CommissionError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "CommissionError";
-  }
-}
-var RATE = /^\d+(\.\d+)?$/;
-function assertRate(rate, field) {
-  if (typeof rate !== "string") {
-    throw new CommissionError("BAD_RATE", `${field} must be a decimal STRING, not a ${typeof rate}. A rate as a float literal is how 0.3 becomes 0.30000000000000004.`);
-  }
-  if (!RATE.test(rate.trim()) || Number(rate) > 1) {
-    throw new CommissionError("BAD_RATE", `${field} must be a decimal string between 0 and 1, not "${rate}". A rate as a float literal is how 0.3 becomes 0.30000000000000004.`);
-  }
-}
-function periodProfit(performance) {
-  const asset = performance.openingEquity.asset;
-  for (const [name, amount] of Object.entries(performance)) {
-    if (amount.asset !== asset) {
-      throw new CommissionError("ASSET_MISMATCH", `${name} is in ${amount.asset} and the period opens in ${asset}.`);
-    }
-  }
-  const gross = subtract(performance.closingEquity, performance.openingEquity);
-  return add(subtract(gross, performance.deposits), performance.withdrawals);
-}
-function chargeableProfit(performance) {
-  const asset = performance.openingEquity.asset;
-  const profit = periodProfit(performance);
-  if (profit.units <= 0n)
-    return zero(asset);
-  const netClosing = add(subtract(performance.closingEquity, performance.deposits), performance.withdrawals);
-  if (netClosing.units <= performance.highWaterMark.units)
-    return zero(asset);
-  const aboveMark = subtract(netClosing, performance.highWaterMark);
-  return aboveMark.units < profit.units ? aboveMark : profit;
-}
-var nextHighWaterMark = (performance) => {
-  const netClosing = add(subtract(performance.closingEquity, performance.deposits), performance.withdrawals);
-  return netClosing.units > performance.highWaterMark.units ? netClosing : performance.highWaterMark;
-};
-function splitCommission(input) {
-  assertRate(input.commissionRate, "The commission rate");
-  if (input.referralRate)
-    assertRate(input.referralRate, "The referral rate");
-  const asset = input.profit.asset;
-  if (input.profit.units <= 0n) {
-    return { total: zero(asset), platform: zero(asset), referral: zero(asset) };
-  }
-  const total = mulRate(input.profit, input.commissionRate, "down");
-  if (!input.referrer || !input.referralRate || total.units === 0n) {
-    return { total, platform: total, referral: zero(asset) };
-  }
-  const referral = mulRate(total, input.referralRate, "down");
-  return {
-    total,
-    platform: subtract(total, referral),
-    referral,
-    referrer: input.referrer
-  };
-}
-function commissionTransaction(args) {
-  if (args.split.total.units === 0n)
-    return null;
-  const revenue = args.revenueAccount ?? { kind: "platform", owner: "revenue" };
-  const from = { kind: "user", owner: args.owner, bucket: "available" };
-  if (args.split.referral.units === 0n) {
-    return transfer({
-      reference: args.reference,
-      kind: "commission",
-      from,
-      to: revenue,
-      amount: args.split.total,
-      atMs: args.atMs
-    });
-  }
-  return {
-    reference: args.reference,
-    kind: "commission",
-    atMs: args.atMs,
-    memo: `commission with referral to ${args.split.referrer}`,
-    entries: [
-      { account: from, amount: { units: -args.split.total.units, asset: args.split.total.asset } },
-      { account: revenue, amount: args.split.platform },
-      {
-        account: { kind: "user", owner: args.split.referrer, bucket: "available" },
-        amount: args.split.referral
-      }
-    ]
-  };
-}
-function projectPrepay(input) {
-  assertRate(input.projectedReturnRate, "The projected return");
-  assertRate(input.commissionRate, "The commission rate");
-  assertRate(input.prepayRate, "The prepay rate");
-  const projectedProfit = mulRate(input.subscriptionAmount, input.projectedReturnRate, "down");
-  const projectedCommission = mulRate(projectedProfit, input.commissionRate, "down");
-  return {
-    projectedProfit,
-    projectedCommission,
-    due: mulRate(projectedCommission, input.prepayRate, "down")
-  };
-}
-function splitReferrals(income, shares) {
-  let remaining = income;
-  const paid = [];
-  for (const share of shares) {
-    assertRate(share.rate, `The rate for ${share.referrer}`);
-    const amount = mulRate(income, share.rate, "down");
-    if (amount.units === 0n)
-      continue;
-    if (amount.units > remaining.units) {
-      throw new CommissionError("BAD_RATE", `Referral rates total more than the income of ${formatAmount(income, { trim: true })} ${income.asset}.`);
-    }
-    remaining = subtract(remaining, amount);
-    paid.push({ referrer: share.referrer, amount });
-  }
-  return { platform: remaining, paid };
-}
-export {
-  splitReferrals,
-  splitCommission,
-  projectPrepay,
-  periodProfit,
-  nextHighWaterMark,
-  commissionTransaction,
-  chargeableProfit,
-  allocate,
-  CommissionError
-};

package/dist/finance/custody.d.ts

@@ -1,68 +0,0 @@
-export declare class CustodyError extends Error {
-    readonly code: 'MALFORMED' | 'NOT_AN_ADDRESS' | 'BAD_THRESHOLD';
-    constructor(code: 'MALFORMED' | 'NOT_AN_ADDRESS' | 'BAD_THRESHOLD', message: string);
-}
-/**
- * EIP-55 checksum.
- *
- * A lowercase address is valid and checks nothing. The mixed-case form catches
- * a mistyped character, which for a treasury destination is the difference
- * between a failed transaction and an unrecoverable one.
- */
-export declare function toChecksumAddress(address: string): string;
-/**
- * A salt from a namespace and a key.
- *
- * The contract treats a salt as opaque, so the CONVENTION is the platform's.
- * This only makes it consistent: a namespace stops a user key and an invoice
- * key that happen to share a value from deriving the same address, which would
- * silently merge two balances.
- */
-export declare function saltFor(namespace: string, key: string): string;
-/**
- * The CREATE2 deposit address for a salt.
- *
- * `keccak256(0xff ++ factory ++ salt ++ initCodeHash)`, last 20 bytes. The
- * init-code hash comes from the deployed factory's `PROXY_INIT_CODE_HASH`
- * rather than being hardcoded: a compiler change alters it, and a stale
- * constant would derive addresses the factory cannot sweep.
- */
-export declare function depositAddress(args: {
-    factory: string;
-    salt: string;
-    proxyInitCodeHash: string;
-}): string;
-export declare function domainSeparator(args: {
-    chainId: bigint;
-    vault: string;
-}): string;
-/**
- * What each custodian signs, computed offline.
- *
- * Four things are inside it and each closes a replay: `chainId` stops a testnet
- * rehearsal executing on mainnet, `vault` stops approvals for one deployment
- * being pointed at another, `nonce` makes an approval spendable once, and the
- * request itself means changing the amount or destination voids every signature
- * already collected.
- */
-export declare function withdrawDigest(args: {
-    chainId: bigint;
-    vault: string;
-    token: string;
-    to: string;
-    amount: bigint;
-    nonce: bigint;
-}): string;
-/**
- * Order signatures the way the vault requires: ascending by signer address.
- *
- * Not cosmetic. The contract uses strict ordering to reject the same custodian
- * signing twice in one submission, so an unsorted batch of otherwise valid
- * approvals is refused — and a batch sorted the wrong way makes an M-of-N vault
- * satisfiable by one custodian.
- */
-export declare function orderSignatures(signatures: readonly {
-    signer: string;
-    signature: string;
-}[]): string[];
-export declare const VERSION = "0.1.0";

package/dist/finance/custody.js

@@ -1,107 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/finance/custody.ts
-import { keccak_256 } from "@noble/hashes/sha3.js";
-var hex = (bytes) => [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
-var bytes = (value) => {
-  const bare = value.replace(/^0x/i, "");
-  if (bare.length % 2)
-    throw new CustodyError("MALFORMED", `Not byte-aligned: ${value}`);
-  const out = new Uint8Array(bare.length / 2);
-  for (let i = 0;i < out.length; i++)
-    out[i] = parseInt(bare.slice(i * 2, i * 2 + 2), 16);
-  return out;
-};
-var concat = (...parts) => {
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
-  let at = 0;
-  for (const part of parts) {
-    out.set(part, at);
-    at += part.length;
-  }
-  return out;
-};
-
-class CustodyError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "CustodyError";
-  }
-}
-var assertAddress = (value, what) => {
-  if (!/^0x[0-9a-fA-F]{40}$/.test(value)) {
-    throw new CustodyError("NOT_AN_ADDRESS", `${what} is not an address: ${value}`);
-  }
-  return value;
-};
-function toChecksumAddress(address) {
-  const bare = assertAddress(address, "address").slice(2).toLowerCase();
-  const digest = hex(keccak_256(new TextEncoder().encode(bare)));
-  let out = "0x";
-  for (let i = 0;i < bare.length; i++) {
-    out += parseInt(digest[i], 16) >= 8 ? bare[i].toUpperCase() : bare[i];
-  }
-  return out;
-}
-function saltFor(namespace, key) {
-  return `0x${hex(keccak_256(new TextEncoder().encode(`${namespace}:${key}`)))}`;
-}
-function depositAddress(args) {
-  assertAddress(args.factory, "factory");
-  const salt = bytes(args.salt);
-  if (salt.length !== 32)
-    throw new CustodyError("MALFORMED", "A salt is 32 bytes.");
-  const initCodeHash = bytes(args.proxyInitCodeHash);
-  if (initCodeHash.length !== 32)
-    throw new CustodyError("MALFORMED", "An init code hash is 32 bytes.");
-  const digest = keccak_256(concat(Uint8Array.of(255), bytes(args.factory), salt, initCodeHash));
-  return toChecksumAddress(`0x${hex(digest.slice(12))}`);
-}
-var keccakText = (value) => keccak_256(new TextEncoder().encode(value));
-var word = (value) => {
-  const raw = typeof value === "bigint" ? value.toString(16) : value.replace(/^0x/i, "");
-  return bytes(raw.padStart(64, "0"));
-};
-var DOMAIN_TYPEHASH = keccakText("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
-var WITHDRAW_TYPEHASH = keccakText("Withdraw(address token,address to,uint256 amount,uint256 nonce)");
-function domainSeparator(args) {
-  assertAddress(args.vault, "vault");
-  return `0x${hex(keccak_256(concat(DOMAIN_TYPEHASH, keccakText("ForgeZeroColdVault"), keccakText("1"), word(args.chainId), word(args.vault))))}`;
-}
-function withdrawDigest(args) {
-  assertAddress(args.to, "to");
-  assertAddress(args.token, "token");
-  const structHash = keccak_256(concat(WITHDRAW_TYPEHASH, word(args.token), word(args.to), word(args.amount), word(args.nonce)));
-  const separator = bytes(domainSeparator({ chainId: args.chainId, vault: args.vault }));
-  return `0x${hex(keccak_256(concat(Uint8Array.of(25, 1), separator, structHash)))}`;
-}
-function orderSignatures(signatures) {
-  const seen = new Set;
-  for (const entry of signatures) {
-    const key = assertAddress(entry.signer, "signer").toLowerCase();
-    if (seen.has(key)) {
-      throw new CustodyError("BAD_THRESHOLD", `${entry.signer} signed twice; that is one approval.`);
-    }
-    seen.add(key);
-  }
-  return [...signatures].sort((a, b) => BigInt(a.signer) < BigInt(b.signer) ? -1 : 1).map((entry) => entry.signature);
-}
-var VERSION = "0.1.0";
-export {
-  withdrawDigest,
-  toChecksumAddress,
-  saltFor,
-  orderSignatures,
-  domainSeparator,
-  depositAddress,
-  VERSION,
-  CustodyError
-};