n3-sdk 0.1.9 → 0.1.11

package/dist/{depositHYPE-CPyMiClY.d.ts → ActionTypes-jfP4j8Od.d.ts}

@@ -404,4 +404,142 @@ declare function depositHYPE({ clients, pool, chainId, amountWei, seed, store, }
     note: NoteV1;
 }>;
 
-export { type AssetId as A, type N3Env as N, Receiver as R, Topics as T, makeCandlesInfo as a, makeDepthInfo as b, makeTradesInfo as c, makeBatchesInfo as d, makeIndicatives as e, makeCandles as f, makeDepth as g, makeTrades as h, makeBatches as i, type TopicName as j, index$1 as k, index as l, makeIndicativesInfo as m, NoteStore as n, type N3Clients as o, toReceiverFromBlock as p, depositERC20 as q, depositHYPE as r, toViemFromBlock as t };
+type Tif = "Alo" | "Ioc" | "Gtc";
+type OrderType = {
+    limit: {
+        tif: Tif;
+    };
+} | {
+    trigger: {
+        isMarket: boolean;
+        triggerPx: string;
+        tpsl: "tp" | "sl";
+    };
+};
+type Cloid = `0x${string}`;
+interface HlOrderWire {
+    a: number;
+    b: boolean;
+    p: string;
+    s: string;
+    r: boolean;
+    t: OrderType;
+    c?: Cloid;
+}
+type Grouping = "na" | "normalTpsl" | "positionTpsl";
+interface BuilderFee {
+    b: `0x${string}`;
+    f: number;
+}
+interface HlActionOrder {
+    type: "order";
+    orders: HlOrderWire[];
+    grouping: Grouping;
+    builder?: BuilderFee;
+}
+interface HlSignature {
+    vaultAddress?: `0x${string}`;
+    expiresAfter: number;
+    [k: string]: unknown;
+}
+interface HlOrderRequest {
+    action: HlActionOrder;
+    nonce: number;
+    signature: HlSignature;
+    [k: string]: unknown;
+}
+type SettlementMode = "pool" | "core" | "hybrid";
+type PoolId = number;
+interface HybridPolicy {
+    internalFirst?: boolean;
+    internalCap?: string;
+    coreCap?: string;
+}
+interface SpendNoteRef {
+    commitment: string;
+    leafIndex?: number;
+    assetId?: number;
+    maxSpend?: string;
+}
+interface RfqConstraints {
+    validUntilMs?: number;
+    minFill?: string;
+    slippageBps?: number;
+    makerOnlyInternal?: boolean;
+    counterpartyAllow?: string[];
+    counterpartyDeny?: string[];
+}
+interface PoolAccess {
+    allowPools?: PoolId[];
+    denyPools?: PoolId[];
+    attestations?: string[];
+}
+interface CoreExecPrefs {
+    route?: string;
+    extData?: string;
+}
+interface N3Extensions {
+    settlement: SettlementMode;
+    pools?: PoolAccess;
+    hybrid?: HybridPolicy;
+    spendNotes?: SpendNoteRef[];
+    rfq?: RfqConstraints;
+    core?: CoreExecPrefs;
+    meta?: Record<string, unknown>;
+}
+interface N3OrderIntent extends HlOrderRequest {
+    n3: N3Extensions;
+}
+interface PlannableOrder {
+    assetId: number;
+    isBuy: boolean;
+    price: string;
+    size: string;
+    reduceOnly: boolean;
+    tif: Tif | null;
+    trigger?: {
+        isMarket: boolean;
+        triggerPx: string;
+        tpsl: "tp" | "sl";
+    };
+    cloid?: Cloid;
+    grouping: Grouping;
+    builder?: BuilderFee;
+    settlement: SettlementMode;
+    pools: Required<PoolAccess>;
+    hybrid: Required<HybridPolicy>;
+    spendNotes: SpendNoteRef[];
+    rfq: Required<RfqConstraints>;
+    core: Required<CoreExecPrefs>;
+    internalRemaining: string;
+    coreRemaining: string;
+    userAddress?: `0x${string}`;
+    receivedAtMs: number;
+}
+type SubmitOrderIntentParams = {
+    hl: HlOrderWire;
+    grouping: Grouping;
+    builder?: BuilderFee;
+    n3?: N3Extensions;
+    ctx?: {
+        defaultPools?: number[];
+        nowMs?: number;
+        userAddress?: `0x${string}`;
+    };
+    domain: {
+        pool: `0x${string}`;
+        chainIdDec: number | string;
+        DOMAIN_DEC: number | string;
+    };
+    nonce?: number;
+    signature?: any;
+};
+
+type WDOut = {
+    assetId: bigint;
+    amount: bigint;
+    pubkey: bigint;
+    blinding: bigint;
+};
+
+export { type AssetId as A, type N3OrderIntent as N, type PlannableOrder as P, type RfqConstraints as R, type SubmitOrderIntentParams as S, Topics as T, type WDOut as W, type SpendNoteRef as a, NoteStore as b, type N3Env as c, makeCandlesInfo as d, makeDepthInfo as e, makeTradesInfo as f, makeBatchesInfo as g, makeIndicatives as h, makeCandles as i, makeDepth as j, makeTrades as k, makeBatches as l, makeIndicativesInfo as m, type TopicName as n, index$1 as o, index as p, Receiver as q, type N3Clients as r, toReceiverFromBlock as s, toViemFromBlock as t, depositERC20 as u, depositHYPE as v };

package/dist/{chunk-MPHJAU3W.js → chunk-7XKOPXQE.js}

@@ -2819,9 +2819,9 @@ var FR = 21888242871839275222246405745257275088548364400416034343698204186575808
 async function babyjubCtx() {
   const babyjub = await buildBabyjub();
   const poseidon = await buildPoseidon();
-  const eddsa = await buildEddsa();
+  const eddsa2 = await buildEddsa();
   const F = babyjub.F;
-  return { babyjub, poseidon, eddsa, F };
+  return { babyjub, poseidon, eddsa: eddsa2, F };
 }
 function toField(x) {
   let v = x % FR;
@@ -2835,7 +2835,7 @@ function hexTo32Bytes(hex) {
   return bytes;
 }
 async function genNote(seed) {
-  const { eddsa, poseidon, F } = await babyjubCtx();
+  const { eddsa: eddsa2, poseidon, F } = await babyjubCtx();
   const rnd = seed ?? BigInt.asUintN(
     256,
     BigInt(Date.now()) * 0x100000000n + BigInt(Math.floor(Math.random() * 1e9))
@@ -2844,7 +2844,7 @@ async function genNote(seed) {
   const blinding = toField(sk ^ 0xB1E55n);
   const skHex = "0x" + sk.toString(16).padStart(64, "0");
   const skBytes = hexTo32Bytes(skHex);
-  const pub = eddsa.prv2pub(skBytes);
+  const pub = eddsa2.prv2pub(skBytes);
   const Ax = F.toObject(pub[0]);
   const Ay = F.toObject(pub[1]);
   const pubkey = F.toObject(poseidon([Ax, Ay]));
@@ -2989,6 +2989,274 @@ async function depositHYPE({
   return { hash, receipt, note };
 }
 
+// src/lib/utils/fetchPinFromIndexer.ts
+async function fetchPinFromIndexer(indexerUrl, poolAddr) {
+  const q = `
+      query Head($pool: String!) {
+        poolStates(where: { id: $pool }, limit: 1) {
+          items { currentRoot depAppliedHash depAppliedLen nextIndex updatedAt }
+        }
+      }`;
+  const r = await fetch(indexerUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query: q, variables: { pool: poolAddr.toLowerCase() } })
+  });
+  const j = await r.json();
+  const head = j?.data?.poolStates?.items?.[0];
+  if (!head) throw new Error("indexer head not found for pool");
+  return {
+    depEnqHash: String(head.depAppliedHash),
+    depEnqLen: Number(head.depAppliedLen),
+    nextIndex: Number(head.nextIndex),
+    currentRoot: head.currentRoot,
+    updatedAt: Number(head.updatedAt)
+  };
+}
+
+// src/lib/utils/withN3Defaults.ts
+function withN3Defaults(n3, ctx = {}) {
+  const settlement = n3?.settlement ?? "pool";
+  const pools = {
+    allowPools: n3?.pools?.allowPools ?? (ctx.defaultPools ?? []),
+    denyPools: n3?.pools?.denyPools ?? [],
+    attestations: n3?.pools?.attestations ?? []
+  };
+  const hybrid = {
+    internalFirst: n3?.hybrid?.internalFirst ?? true,
+    internalCap: n3?.hybrid?.internalCap ?? (ctx.size ?? "0"),
+    coreCap: n3?.hybrid?.coreCap ?? (ctx.size ?? "0")
+  };
+  const spendNotes = n3?.spendNotes ?? [];
+  const now = ctx.nowMs ?? Date.now();
+  const rfq = {
+    validUntilMs: n3?.rfq?.validUntilMs ?? now + 5 * 6e4,
+    // default 5 min
+    minFill: n3?.rfq?.minFill ?? "0",
+    slippageBps: n3?.rfq?.slippageBps ?? 0,
+    makerOnlyInternal: n3?.rfq?.makerOnlyInternal ?? false,
+    counterpartyAllow: n3?.rfq?.counterpartyAllow ?? [],
+    counterpartyDeny: n3?.rfq?.counterpartyDeny ?? []
+  };
+  const core = {
+    route: n3?.core?.route ?? "",
+    extData: n3?.core?.extData ?? ""
+  };
+  const meta = n3?.meta ?? {};
+  return { settlement, pools, hybrid, spendNotes, rfq, core, meta };
+}
+
+// src/lib/utils/normalizeOrder.ts
+function normalizeOrder(hl, grouping, builder, n3Full, extra) {
+  const tif = "limit" in hl.t ? hl.t.limit.tif : null;
+  const trigger = "trigger" in hl.t ? hl.t.trigger : void 0;
+  const it = {
+    assetId: hl.a,
+    isBuy: hl.b,
+    price: hl.p,
+    size: hl.s,
+    reduceOnly: hl.r,
+    tif,
+    trigger,
+    cloid: hl.c,
+    grouping,
+    builder,
+    settlement: n3Full.settlement,
+    pools: n3Full.pools,
+    hybrid: n3Full.hybrid,
+    spendNotes: n3Full.spendNotes,
+    rfq: n3Full.rfq,
+    core: n3Full.core,
+    internalRemaining: n3Full.hybrid.internalFirst ? n3Full.hybrid.internalCap : "0",
+    coreRemaining: n3Full.hybrid.coreCap,
+    userAddress: extra.userAddress,
+    receivedAtMs: extra.receivedAtMs ?? Date.now()
+  };
+  return it;
+}
+
+// src/lib/utils/stripForHyperliquid.ts
+function stripForHyperliquid(intent) {
+  const { n3: _omit, ...rest } = intent;
+  return rest;
+}
+
+// src/lib/utils/toUint160Dec.ts
+function toUint160Dec(addr) {
+  if (!addr) throw new Error("empty address");
+  const hex = addr.toLowerCase();
+  if (!hex.startsWith("0x") || hex.length !== 42) throw new Error(`bad address: ${addr}`);
+  return BigInt(hex).toString();
+}
+
+// src/lib/utils/getDomains.ts
+function getDomains(params) {
+  return {
+    domainA: toUint160Dec(params.pool),
+    domainB: String(params.chainIdDec),
+    DOMAIN: String(params.DOMAIN_DEC)
+  };
+}
+
+// src/lib/utils/notesSelect.ts
+function greedySelectNotes(store, params) {
+  const assetIdBI = BigInt(params.assetId);
+  const need = params.amount;
+  const spendables = store.listSpendable({ assetId: assetIdBI }).filter((n) => n.index != null && !!n.commitment);
+  const sorted = spendables.slice().sort((a, b) => b.amount > a.amount ? 1 : b.amount < a.amount ? -1 : 0);
+  const out = [];
+  let acc = 0n;
+  for (const n of sorted) {
+    out.push(n);
+    acc += n.amount;
+    if (acc >= need) break;
+  }
+  return { notes: out, totalSelected: acc, shortfall: acc >= need ? 0n : need - acc };
+}
+function buildSpendNotesFromStore(store, params) {
+  const sel = greedySelectNotes(store, params);
+  const spendNotes = sel.notes.map((n) => ({
+    commitment: n.commitment,
+    leafIndex: n.index,
+    // anchored by filter above
+    assetId: Number(n.assetId),
+    maxSpend: n.amount.toString()
+    // spend full note; change handled downstream
+  }));
+  return { spendNotes, totalSelected: sel.totalSelected, shortfall: sel.shortfall };
+}
+
+// src/lib/utils/pureSigner.ts
+import { buildBabyjub as buildBabyjub2, buildEddsa as buildEddsa2, buildPoseidonReference } from "circomlibjs";
+globalThis.ffjsconfig = { wasm: "disable" };
+process.env.FFJS_FORCE_NO_WASM = "1";
+process.env.FFJSCONFIG = '{"wasm":"disable"}';
+var babyJub = await buildBabyjub2();
+var eddsa = await buildEddsa2();
+var poseidonRef = await buildPoseidonReference();
+var Fr = babyJub.F;
+function toBI(x) {
+  return typeof x === "bigint" ? x : BigInt(x);
+}
+function be32FromDec(dec) {
+  let x = toBI(dec);
+  const out = new Uint8Array(32);
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  return out;
+}
+function hexToBytes(hex) {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const s = h.padStart(64, "0");
+  return Uint8Array.from(Buffer.from(s, "hex"));
+}
+function H2(a, b) {
+  return Fr.toObject(poseidonRef([Fr.e(a), Fr.e(b)]));
+}
+function noteCommit(assetId, amount, pubkey, blinding) {
+  const h2 = (x, y) => Fr.toObject(poseidonRef([Fr.e(x), Fr.e(y)]));
+  return h2(h2(assetId, amount), h2(pubkey, blinding));
+}
+function msgHash(domain, chainDec, poolDec, c_in, oldRoot) {
+  return Fr.toObject(
+    poseidonRef([
+      Fr.e(domain),
+      Fr.e(chainDec),
+      Fr.e(poolDec),
+      Fr.e(c_in),
+      Fr.e(oldRoot)
+    ])
+  );
+}
+function poseidonAxAy(Ax, Ay) {
+  return Fr.toObject(
+    poseidonRef([Fr.e(toBI(Ax)), Fr.e(toBI(Ay))])
+  );
+}
+function signPoseidonCompat(prvSeed, M, Ax_from_note, Ay_from_note) {
+  const raw = prvSeed.startsWith("0x") ? hexToBytes(prvSeed) : be32FromDec(prvSeed);
+  if (raw.length !== 32) {
+    throw new Error(`signPoseidonCompat: prvSeed must be 32 bytes, got ${raw.length}`);
+  }
+  const prv = Buffer.from(raw);
+  if (Ax_from_note && Ay_from_note) {
+    const A = eddsa.prv2pub(prv);
+    const Ax = Fr.toObject(A[0]);
+    const Ay = Fr.toObject(A[1]);
+    if (Ax.toString() !== Ax_from_note || Ay.toString() !== Ay_from_note) {
+      console.warn("[warn] prv->pub mismatch", {
+        derivedAx: Ax.toString(),
+        derivedAy: Ay.toString(),
+        noteAx: Ax_from_note,
+        noteAy: Ay_from_note
+      });
+    }
+  }
+  const Mfield = Fr.e(M);
+  const sig = eddsa.signPoseidon(prv, Mfield);
+  const R8x = Fr.toObject(sig.R8[0]);
+  const R8y = Fr.toObject(sig.R8[1]);
+  const S = toBI(sig.S);
+  return { R8x: R8x.toString(), R8y: R8y.toString(), S: S.toString() };
+}
+function verifyPoseidonCompat(Ax, Ay, M, sig) {
+  const A = [babyJub.F.e(toBI(Ax)), babyJub.F.e(toBI(Ay))];
+  const R8 = [babyJub.F.e(toBI(sig.R8x)), babyJub.F.e(toBI(sig.R8y))];
+  const S = toBI(sig.S);
+  return eddsa.verifyPoseidon(M, { R8, S }, A);
+}
+
+// src/lib/utils/formattingHelpers.ts
+import crypto3 from "crypto";
+var BI = (x) => typeof x === "bigint" ? x : BigInt(x);
+var mask160 = (1n << 160n) - 1n;
+var toHex32Lower = (x) => {
+  const bi = typeof x === "bigint" ? x : x.toString().startsWith("0x") ? BigInt(x) : BigInt(x);
+  return "0x" + bi.toString(16).padStart(64, "0");
+};
+function toU8(objOrHexOrU8) {
+  if (objOrHexOrU8 instanceof Uint8Array) return objOrHexOrU8;
+  if (typeof objOrHexOrU8 === "string") {
+    const hex = objOrHexOrU8.startsWith("0x") ? objOrHexOrU8.slice(2) : objOrHexOrU8;
+    if (hex.length % 2) throw new Error("hex string must have even length");
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++) out[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
+    return out;
+  }
+  if (objOrHexOrU8 && typeof objOrHexOrU8 === "object") {
+    const keys = Object.keys(objOrHexOrU8).map(Number).sort((a, b) => a - b);
+    const out = new Uint8Array(keys.length);
+    for (let i = 0; i < keys.length; i++) out[i] = Number(objOrHexOrU8[keys[i]]);
+    return out;
+  }
+  throw new Error("toU8: unsupported input");
+}
+var u8ToHex = (u82) => "0x" + [...u82].map((b) => b.toString(16).padStart(2, "0")).join("");
+var u8ToBigIntBE = (u82) => BigInt(u8ToHex(u82));
+var randU256 = () => u8ToBigIntBE(crypto3.randomBytes(32));
+
+// src/lib/utils/foldToRoot.ts
+function foldToRoot(leaf, pathElements, pathIndex, depth) {
+  let acc = leaf;
+  for (let lvl = 0; lvl < depth; lvl++) {
+    const sib = BI(pathElements[lvl]);
+    const bit = pathIndex[lvl] & 1;
+    acc = bit === 0 ? H2(acc, sib) : H2(sib, acc);
+  }
+  return acc;
+}
+
+// src/lib/utils/computeNullifier.ts
+async function computeNullifierExact(params) {
+  await initPoseidon();
+  const H22 = getH2();
+  const inner = H22(params.commit, params.index);
+  const nf = H22(params.sk, inner);
+  return nf;
+}
+
 export {
   __export,
   Topics,
@@ -3009,13 +3277,32 @@ export {
   toViemFromBlock,
   toReceiverFromBlock,
   initPoseidon,
-  getH2,
   PrivatePoolAbi,
   EV_NewRoot,
   EV_LeavesInserted,
   EV_Spent,
   depositERC20,
-  depositHYPE
+  depositHYPE,
+  fetchPinFromIndexer,
+  withN3Defaults,
+  normalizeOrder,
+  stripForHyperliquid,
+  toUint160Dec,
+  getDomains,
+  buildSpendNotesFromStore,
+  H2,
+  noteCommit,
+  msgHash,
+  poseidonAxAy,
+  signPoseidonCompat,
+  verifyPoseidonCompat,
+  BI,
+  toHex32Lower,
+  toU8,
+  u8ToBigIntBE,
+  randU256,
+  foldToRoot,
+  computeNullifierExact
 };
 /*! Bundled license information:
 
@@ -3025,4 +3312,4 @@ export {
 @noble/hashes/esm/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-MPHJAU3W.js.map
+//# sourceMappingURL=chunk-7XKOPXQE.js.map