@unlink-xyz/core 0.1.0

package/dist/account/zkAccount.d.ts

@@ -0,0 +1,38 @@
+import { type SpendingKeyPair, type ViewingKeyPair } from "../key-derivation/wallet-node.js";
+import type { Storage } from "../types.js";
+export type MasterSeedCrypto = {
+    encrypt(seed: Uint8Array): Promise<Uint8Array> | Uint8Array;
+    decrypt(payload: Uint8Array): Promise<Uint8Array> | Uint8Array;
+};
+export type GenerateMasterSeedOptions = {
+    storage: Storage;
+    rng: (n: number) => Uint8Array;
+    crypto?: MasterSeedCrypto;
+    overwrite?: boolean;
+    mnemonicPassphrase: string;
+};
+export declare const MASTER_SEED_LENGTH = 64;
+export declare const MASTER_SEED_KEY = "cfg:wallet:master_seed/v1";
+export declare const MASTER_MNEMONIC_KEY = "cfg:wallet:master_mnemonic/v1";
+export type ZkAccount = {
+    spendingKeyPair: SpendingKeyPair;
+    viewingKeyPair: ViewingKeyPair;
+    nullifyingKey: bigint;
+    masterPublicKey: bigint;
+};
+export declare function deriveZkAccount(masterSeed: Uint8Array, accountIndex?: number): Promise<ZkAccount>;
+export declare function deriveZkAccountFromMnemonic(mnemonic: string, accountIndex?: number, password?: string): Promise<ZkAccount>;
+export declare function generateMasterSeed({ storage, rng, crypto, overwrite, mnemonicPassphrase, }: GenerateMasterSeedOptions): Promise<Uint8Array>;
+export declare function loadMasterSeed(storage: Storage, crypto?: MasterSeedCrypto): Promise<Uint8Array | null>;
+export declare function storeMasterSeed(storage: Storage, seed: Uint8Array, crypto?: MasterSeedCrypto): Promise<void>;
+export declare function loadMasterMnemonic(storage: Storage, crypto?: MasterSeedCrypto): Promise<string | null>;
+export type ImportMasterMnemonicOptions = {
+    storage: Storage;
+    mnemonic: string;
+    crypto?: MasterSeedCrypto;
+    overwrite?: boolean;
+    password?: string;
+};
+export declare function importMasterMnemonic({ storage, mnemonic, crypto, overwrite, password, }: ImportMasterMnemonicOptions): Promise<Uint8Array>;
+export declare function storeMasterMnemonic(storage: Storage, mnemonic: string, crypto?: MasterSeedCrypto): Promise<void>;
+//# sourceMappingURL=zkAccount.d.ts.map

package/dist/account/zkAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zkAccount.d.ts","sourceRoot":"","sources":["../../account/zkAccount.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EACpB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;IAC5D,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;CAChE,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;IAC/B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAC3D,eAAO,MAAM,mBAAmB,kCAAkC,CAAC;AAOnE,MAAM,MAAM,SAAS,GAAG;IACtB,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAsB,eAAe,CACnC,UAAU,EAAE,UAAU,EACtB,YAAY,GAAE,MAAU,GACvB,OAAO,CAAC,SAAS,CAAC,CAqBpB;AAED,wBAAsB,2BAA2B,CAC/C,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,MAAU,EACxB,QAAQ,GAAE,MAAW,GACpB,OAAO,CAAC,SAAS,CAAC,CAIpB;AAWD,wBAAsB,kBAAkB,CAAC,EACvC,OAAO,EACP,GAAG,EACH,MAAiC,EACjC,SAAiB,EACjB,kBAAkB,GACnB,EAAE,yBAAyB,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BjD;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAK5B;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMxB;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAsB,oBAAoB,CAAC,EACzC,OAAO,EACP,QAAQ,EACR,MAAiC,EACjC,SAAiB,EACjB,QAAa,GACd,EAAE,2BAA2B,GAAG,OAAO,CAAC,UAAU,CAAC,CAenD;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,IAAI,CAAC,CAOf"}

package/dist/account/zkAccount.js

@@ -0,0 +1,128 @@
+import { Mnemonic } from "../key-derivation/bip39.js";
+import { ByteUtils } from "../key-derivation/bytes.js";
+import { deriveNodesFromSeed, WalletNode, } from "../key-derivation/wallet-node.js";
+export const MASTER_SEED_LENGTH = 64;
+export const MASTER_SEED_KEY = "cfg:wallet:master_seed/v1";
+export const MASTER_MNEMONIC_KEY = "cfg:wallet:master_mnemonic/v1";
+const MNEMONIC_ENTROPY_BYTES = 32;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+export async function deriveZkAccount(masterSeed, accountIndex = 0) {
+    const seed = normalizeMasterSeed(masterSeed);
+    if (!Number.isInteger(accountIndex) || accountIndex < 0) {
+        throw new Error("accountIndex must be a non-negative integer");
+    }
+    const { spending, viewing } = deriveNodesFromSeed(seed, accountIndex);
+    const spendingKeyPair = spending.getSpendingKeyPair();
+    const viewingKeyPair = await viewing.getViewingKeyPair();
+    const nullifyingKey = WalletNode.getNullifyingKey(viewingKeyPair.privateKey);
+    const masterPublicKey = WalletNode.getMasterPublicKey(spendingKeyPair.pubkey, nullifyingKey);
+    return {
+        spendingKeyPair,
+        viewingKeyPair,
+        nullifyingKey,
+        masterPublicKey,
+    };
+}
+export async function deriveZkAccountFromMnemonic(mnemonic, accountIndex = 0, password = "") {
+    const normalized = normalizeMnemonic(mnemonic);
+    const seed = mnemonicToSeed(normalized, password);
+    return deriveZkAccount(seed, accountIndex);
+}
+const identityMasterSeedCrypto = {
+    encrypt(seed) {
+        return clone(seed);
+    },
+    decrypt(payload) {
+        return clone(payload);
+    },
+};
+export async function generateMasterSeed({ storage, rng, crypto = identityMasterSeedCrypto, overwrite = false, mnemonicPassphrase, }) {
+    if (!overwrite) {
+        const existingSeed = await loadMasterSeed(storage, crypto);
+        if (existingSeed)
+            return existingSeed;
+        const existingMnemonic = await loadMasterMnemonic(storage, crypto);
+        if (existingMnemonic) {
+            const seedFromMnemonic = mnemonicToSeed(existingMnemonic, mnemonicPassphrase);
+            await storeMasterSeed(storage, seedFromMnemonic, crypto);
+            return seedFromMnemonic;
+        }
+    }
+    const entropy = rng(MNEMONIC_ENTROPY_BYTES);
+    if (entropy.length !== MNEMONIC_ENTROPY_BYTES) {
+        throw new Error(`mnemonic entropy must be ${MNEMONIC_ENTROPY_BYTES} bytes`);
+    }
+    const mnemonic = Mnemonic.fromEntropy(ByteUtils.bytesToHex(entropy));
+    await storeMasterMnemonic(storage, mnemonic, crypto);
+    const seed = mnemonicToSeed(mnemonic, mnemonicPassphrase);
+    await storeMasterSeed(storage, seed, crypto);
+    return seed;
+}
+export async function loadMasterSeed(storage, crypto = identityMasterSeedCrypto) {
+    const stored = await storage.get(MASTER_SEED_KEY);
+    if (!stored)
+        return null;
+    const plaintext = await crypto.decrypt(stored);
+    return normalizeMasterSeed(plaintext);
+}
+export async function storeMasterSeed(storage, seed, crypto = identityMasterSeedCrypto) {
+    const normalized = normalizeMasterSeed(seed);
+    const encrypted = await crypto.encrypt(normalized);
+    if (!(encrypted instanceof Uint8Array)) {
+        throw new Error("master seed encryptor must return Uint8Array");
+    }
+    await storage.put(MASTER_SEED_KEY, clone(encrypted));
+}
+export async function loadMasterMnemonic(storage, crypto = identityMasterSeedCrypto) {
+    const stored = await storage.get(MASTER_MNEMONIC_KEY);
+    if (!stored)
+        return null;
+    const plaintext = await crypto.decrypt(stored);
+    const mnemonic = textDecoder.decode(plaintext);
+    return normalizeMnemonic(mnemonic);
+}
+export async function importMasterMnemonic({ storage, mnemonic, crypto = identityMasterSeedCrypto, overwrite = false, password = "", }) {
+    if (!overwrite) {
+        const existing = await loadMasterMnemonic(storage, crypto);
+        if (existing) {
+            throw new Error("master mnemonic already exists; set overwrite to true to replace it");
+        }
+    }
+    const normalized = normalizeMnemonic(mnemonic);
+    const seed = mnemonicToSeed(normalized, password);
+    await storeMasterMnemonic(storage, normalized, crypto);
+    await storeMasterSeed(storage, seed, crypto);
+    return seed;
+}
+export async function storeMasterMnemonic(storage, mnemonic, crypto = identityMasterSeedCrypto) {
+    const normalized = normalizeMnemonic(mnemonic);
+    const encrypted = await crypto.encrypt(textEncoder.encode(normalized));
+    if (!(encrypted instanceof Uint8Array)) {
+        throw new Error("master mnemonic encryptor must return Uint8Array");
+    }
+    await storage.put(MASTER_MNEMONIC_KEY, clone(encrypted));
+}
+function clone(bytes) {
+    return new Uint8Array(bytes);
+}
+function normalizeMasterSeed(seed) {
+    if (!(seed instanceof Uint8Array)) {
+        throw new Error("master seed must be a Uint8Array");
+    }
+    if (seed.length !== MASTER_SEED_LENGTH) {
+        throw new Error(`master seed must be ${MASTER_SEED_LENGTH} bytes`);
+    }
+    return clone(seed);
+}
+function normalizeMnemonic(mnemonic) {
+    const formatted = mnemonic.trim().replace(/\s+/g, " ");
+    if (!Mnemonic.validate(formatted)) {
+        throw new Error("invalid BIP-39 mnemonic phrase");
+    }
+    return formatted;
+}
+function mnemonicToSeed(mnemonic, password = "") {
+    const seedHex = Mnemonic.toSeed(mnemonic, password);
+    return ByteUtils.hexStringToBytes(seedHex);
+}

package/dist/clients/broadcaster.d.ts

@@ -0,0 +1,33 @@
+import type { FetchLike } from "./http.js";
+export type BroadcasterRelayPayload = {
+    kind: "call_data";
+    to: string;
+    data: string;
+};
+export type SubmitRelayParams = {
+    clientTxId: string;
+    chainId: number;
+    payload: BroadcasterRelayPayload;
+};
+export type SubmitRelayResponse = {
+    id: string;
+    accepted: boolean;
+    message?: string | null;
+};
+export type RelayState = "pending" | "broadcasting" | "succeeded" | "failed" | "dead";
+export type RelayStatusResponse = {
+    id: string;
+    state: RelayState;
+    txHash?: string | null;
+    receipt?: unknown;
+    error?: string | null;
+};
+type BroadcasterClientDeps = {
+    fetch: FetchLike;
+};
+export declare function createBroadcasterClient(baseUrl: string, deps: BroadcasterClientDeps): {
+    submitRelay(params: SubmitRelayParams): Promise<SubmitRelayResponse>;
+    getRelayStatus(relayId: string): Promise<RelayStatusResponse>;
+};
+export {};
+//# sourceMappingURL=broadcaster.d.ts.map

package/dist/clients/broadcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcaster.d.ts","sourceRoot":"","sources":["../../clients/broadcaster.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,WAAW,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,uBAAuB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,cAAc,GACd,WAAW,GACX,QAAQ,GACR,MAAM,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,qBAAqB;wBAKC,iBAAiB;4BAYb,MAAM;EAOvC"}

package/dist/clients/broadcaster.js

@@ -0,0 +1,23 @@
+import { createJsonHttpClient } from "./http.js";
+export function createBroadcasterClient(baseUrl, deps) {
+    const http = createJsonHttpClient(baseUrl, deps);
+    return {
+        async submitRelay(params) {
+            return http.request({
+                method: "POST",
+                path: "/relays",
+                json: {
+                    client_tx_id: params.clientTxId,
+                    chain_id: params.chainId,
+                    ...params.payload,
+                },
+            });
+        },
+        async getRelayStatus(relayId) {
+            return http.request({
+                method: "GET",
+                path: `/relays/${relayId}`,
+            });
+        },
+    };
+}

package/dist/clients/http.d.ts

@@ -0,0 +1,23 @@
+export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type JsonHttpDeps = {
+    fetch: FetchLike;
+};
+export type JsonRequestOptions = {
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    json?: unknown;
+    body?: BodyInit;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+};
+export type JsonHttpClient = {
+    request<T>(opts: JsonRequestOptions): Promise<T>;
+};
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export declare function createJsonHttpClient(baseUrl: string, deps: JsonHttpDeps): JsonHttpClient;
+//# sourceMappingURL=http.d.ts.map

package/dist/clients/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../clients/http.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,CACtB,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,IAAI,CAAC,EAAE,WAAW,KACf,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEvB,MAAM,MAAM,YAAY,GAAG;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,CAAC;AAEhD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;IAC9D,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAClD,CAAC;AAEF,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAK3D;AAWD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,YAAY,GACjB,cAAc,CA+ChB"}

package/dist/clients/http.js

@@ -0,0 +1,57 @@
+import ky, { HTTPError, TimeoutError } from "ky";
+export class HttpError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+    }
+}
+async function readErrorBodySafe(res) {
+    try {
+        return await res.clone().json();
+    }
+    catch {
+        const text = await res.text();
+        return text || null;
+    }
+}
+export function createJsonHttpClient(baseUrl, deps) {
+    if (!baseUrl)
+        throw new Error("baseUrl is required");
+    if (!deps?.fetch)
+        throw new Error("deps.fetch is required");
+    // Ensure `fetch` is invoked with a global `this` to avoid "Illegal invocation"
+    // errors in some browser environments when the function is extracted. // TODO: can we fix this in another way?
+    const fetchImpl = (...args) => deps.fetch.apply(globalThis, args);
+    const api = ky.create({
+        prefixUrl: baseUrl.replace(/\/+$/, ""),
+        fetch: fetchImpl,
+    });
+    return {
+        async request(opts) {
+            try {
+                const res = api(opts.path.replace(/^\//, ""), {
+                    method: opts.method,
+                    searchParams: opts.query,
+                    json: opts.json,
+                    body: opts.body,
+                    headers: opts.headers,
+                    signal: opts.signal,
+                });
+                return await res.json();
+            }
+            catch (err) {
+                if (err instanceof HTTPError) {
+                    const body = await readErrorBodySafe(err.response);
+                    throw new HttpError(`HTTP ${err.response.status} ${err.response.statusText}`.trim(), err.response.status, body);
+                }
+                if (err instanceof TimeoutError) {
+                    throw new HttpError("HTTP timeout", 408, null);
+                }
+                throw new HttpError(err instanceof Error ? err.message : "Network error", 0, null);
+            }
+        },
+    };
+}

package/dist/clients/indexer.d.ts

@@ -0,0 +1,44 @@
+import type { FetchLike } from "./http.js";
+export type CommitmentRecord = {
+    index: number;
+    commitment: string;
+    ciphertext: [string, string, string];
+    root: string;
+    txHash: string;
+    insertedAt: number;
+};
+export type IndexerNullifierRecord = {
+    nullifier: string;
+    txHash: string;
+    spentAt: number;
+    chainId: number;
+};
+export type CommitmentBatchResponse = {
+    chainId: number;
+    commitments: CommitmentRecord[];
+    latestRoot: string | null;
+};
+export type FetchCommitmentsParams = {
+    chainId: number;
+    start?: number;
+    limit?: number;
+};
+export type GetCommitmentParams = {
+    chainId: number;
+    commitment: string;
+};
+export type GetNullifierParams = {
+    chainId: number;
+    nullifier: string;
+};
+type IndexerClientDeps = {
+    fetch: FetchLike;
+};
+export declare function createIndexerClient(baseUrl: string, deps: IndexerClientDeps): {
+    fetchCommitmentBatch(params: FetchCommitmentsParams): Promise<CommitmentBatchResponse>;
+    getCommitment(params: GetCommitmentParams): Promise<CommitmentRecord>;
+    getNullifier(params: GetNullifierParams): Promise<IndexerNullifierRecord | null>;
+    getNullifierCount(chainId: number): Promise<number>;
+};
+export {};
+//# sourceMappingURL=indexer.d.ts.map

package/dist/clients/indexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexer.d.ts","sourceRoot":"","sources":["../../clients/indexer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAc3C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AASF,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAQF,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAOF,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB;iCAyB9D,sBAAsB,GAC7B,OAAO,CAAC,uBAAuB,CAAC;0BAgBzB,mBAAmB,GAC1B,OAAO,CAAC,gBAAgB,CAAC;yBAQlB,kBAAkB,GACzB,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC;+BAcR,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;EAQ5D"}

package/dist/clients/indexer.js

@@ -0,0 +1,67 @@
+import { isNotFoundError } from "../utils/async.js";
+import { createJsonHttpClient } from "./http.js";
+export function createIndexerClient(baseUrl, deps) {
+    const http = createJsonHttpClient(baseUrl, deps);
+    // Converts the snake_case record from the REST API into the camelCase shape
+    // the rest of the SDK consumes.
+    const normalizeRecord = (record) => ({
+        index: record.leaf_index,
+        commitment: record.commitment,
+        ciphertext: [...record.ciphertext],
+        root: record.root,
+        txHash: record.tx_hash,
+        insertedAt: record.inserted_at,
+    });
+    const normalizeNullifierRecord = (record) => ({
+        nullifier: record.nullifier,
+        txHash: record.tx_hash,
+        spentAt: record.spent_at,
+        chainId: record.chain_id,
+    });
+    return {
+        async fetchCommitmentBatch(params) {
+            const raw = await http.request({
+                method: "GET",
+                path: `/chains/${params.chainId}/commitments`,
+                query: {
+                    start: params.start,
+                    limit: params.limit,
+                },
+            });
+            return {
+                chainId: raw.chain_id,
+                commitments: raw.commitments.map(normalizeRecord),
+                latestRoot: raw.latest_root,
+            };
+        },
+        async getCommitment(params) {
+            const raw = await http.request({
+                method: "GET",
+                path: `/chains/${params.chainId}/commitments/${params.commitment}`,
+            });
+            return normalizeRecord(raw);
+        },
+        async getNullifier(params) {
+            try {
+                const raw = await http.request({
+                    method: "GET",
+                    path: `/chains/${params.chainId}/nullifiers/${params.nullifier}`,
+                });
+                return normalizeNullifierRecord(raw);
+            }
+            catch (err) {
+                if (isNotFoundError(err)) {
+                    return null; // Nullifier not spent on-chain
+                }
+                throw err;
+            }
+        },
+        async getNullifierCount(chainId) {
+            const raw = await http.request({
+                method: "GET",
+                path: `/chains/${chainId}/nullifiers/count`,
+            });
+            return raw.count;
+        },
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+export declare const serviceConfig: {
+    /**
+     * Base URL for the Broadcaster HTTP API (default: http://localhost:8081).
+     */
+    broadcasterBaseUrl: string;
+    /**
+     * Base URL for the Indexer HTTP API (default: http://localhost:8082).
+     */
+    indexerBaseUrl: string;
+};
+export type ServiceConfig = typeof serviceConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../config.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,aAAa;IACxB;;OAEG;;IAGH;;OAEG;;CAGJ,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC"}

package/dist/config.js

@@ -0,0 +1,29 @@
+const DEFAULT_RPC_URL = "http://localhost:3000";
+function readEnv(key) {
+    if (typeof process !== "undefined" && process?.env) {
+        return process.env[key];
+    }
+    // Support environments where process isn't defined but a shim sets globalThis.process
+    const globalProcess = globalThis.process;
+    return globalProcess?.env?.[key];
+}
+function readServiceUrl(envKey, fallback) {
+    const raw = readEnv(envKey);
+    if (!raw)
+        return fallback;
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error(`${envKey} must not be empty when set`);
+    }
+    return trimmed.replace(/\/+$/, "");
+}
+export const serviceConfig = {
+    /**
+     * Base URL for the Broadcaster HTTP API (default: http://localhost:8081).
+     */
+    broadcasterBaseUrl: readServiceUrl("UNLINK_RPC_URL", DEFAULT_RPC_URL) + "/broadcaster",
+    /**
+     * Base URL for the Indexer HTTP API (default: http://localhost:8082).
+     */
+    indexerBaseUrl: readServiceUrl("UNLINK_RPC_URL", DEFAULT_RPC_URL) + "/indexer",
+};

package/dist/core.d.ts

@@ -0,0 +1,10 @@
+import type { Storage } from "./types.js";
+export type CoreDeps = {
+    storage: Storage;
+    rng: (n: number) => Uint8Array;
+};
+export declare function initCore(deps: CoreDeps): Promise<{
+    storage: Storage;
+    rng: (n: number) => Uint8Array;
+}>;
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../core.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;CAChC,CAAC;AAEF,wBAAsB,QAAQ,CAAC,IAAI,EAAE,QAAQ;;aAHlC,MAAM,KAAK,UAAU;GAW/B"}

package/dist/core.js

@@ -0,0 +1,12 @@
+import { migrate } from "./schema.js";
+export async function initCore(deps) {
+    if (!deps?.storage)
+        throw new Error("storage dep required");
+    if (!deps?.rng)
+        throw new Error("rng dep required");
+    await migrate(deps.storage);
+    return {
+        storage: deps.storage,
+        rng: deps.rng,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class CoreError extends Error {
+    constructor(message: string);
+}
+export declare class KeyValidationError extends CoreError {
+    constructor(message: string);
+}
+export declare class SchemaMismatchError extends CoreError {
+    constructor(current: number, expected: number);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../errors.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAU,SAAQ,KAAK;gBACtB,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,kBAAmB,SAAQ,SAAS;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,mBAAoB,SAAQ,SAAS;gBACpC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAI9C"}

package/dist/errors.js

@@ -0,0 +1,18 @@
+export class CoreError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CoreError";
+    }
+}
+export class KeyValidationError extends CoreError {
+    constructor(message) {
+        super(message);
+        this.name = "KeyValidationError";
+    }
+}
+export class SchemaMismatchError extends CoreError {
+    constructor(current, expected) {
+        super(`schema mismatch (current ${current}, expected ${expected})`);
+        this.name = "SchemaMismatchError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./keys.js";
+export * from "./storage/index.js";
+export * from "./schema.js";
+export * from "./core.js";
+export * from "./state/index.js";
+export * from "./utils/validators.js";
+export * from "./utils/bigint.js";
+export * from "./account/zkAccount.js";
+export * from "./key-derivation/index.js";
+export * from "./transactions/index.js";
+export { createJobReconciler } from "./transactions/reconcile.js";
+export { serviceConfig } from "./config.js";
+export type { ServiceConfig } from "./config.js";
+export * from "./clients/broadcaster.js";
+export * from "./clients/indexer.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./keys.js";
+export * from "./storage/index.js";
+export * from "./schema.js";
+export * from "./core.js";
+export * from "./state/index.js";
+export * from "./utils/validators.js";
+export * from "./utils/bigint.js";
+export * from "./account/zkAccount.js";
+export * from "./key-derivation/index.js";
+export * from "./transactions/index.js";
+export { createJobReconciler } from "./transactions/reconcile.js";
+export { serviceConfig } from "./config.js";
+export * from "./clients/broadcaster.js";
+export * from "./clients/indexer.js";

package/dist/key-derivation/babyjubjub.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lightweight wrapper exposing the BabyJubJub point packing helpers we rely on for
+ * derivation and address encoding. Re-exported for consumers that need raw curve ops.
+ */
+export declare class Babyjubjub {
+    static packPoint: (point: [bigint, bigint]) => Uint8Array;
+    static unpackPoint: (bytes: Uint8Array) => [bigint, bigint];
+}
+//# sourceMappingURL=babyjubjub.d.ts.map

package/dist/key-derivation/babyjubjub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babyjubjub.d.ts","sourceRoot":"","sources":["../../key-derivation/babyjubjub.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,0CAAqB;IAErC,MAAM,CAAC,WAAW,0CAAuB;CAC1C"}

package/dist/key-derivation/babyjubjub.js

@@ -0,0 +1,9 @@
+import { babyjub } from "@railgun-community/circomlibjs";
+/**
+ * Lightweight wrapper exposing the BabyJubJub point packing helpers we rely on for
+ * derivation and address encoding. Re-exported for consumers that need raw curve ops.
+ */
+export class Babyjubjub {
+    static packPoint = babyjub.packPoint;
+    static unpackPoint = babyjub.unpackPoint;
+}

package/dist/key-derivation/bech32.d.ts

@@ -0,0 +1,22 @@
+export type Chain = {
+    type: number;
+    id: number;
+};
+export type AddressData = {
+    masterPublicKey: bigint;
+    viewingPublicKey: Uint8Array;
+    chain?: Chain;
+    version?: number;
+};
+export declare const ADDRESS_VERSION = 1;
+export declare const ADDRESS_LENGTH_LIMIT = 127;
+export declare const ALL_CHAINS_NETWORK_ID = "ffffffffffffffff";
+/**
+ * Encode address metadata into a Bech32m string with the 0zk prefix.
+ */
+export declare const encodeAddress: (addressData: AddressData) => string;
+/**
+ * Decode and validate a Bech32m address, returning the structured payload.
+ */
+export declare const decodeAddress: (address: string) => AddressData;
+//# sourceMappingURL=bech32.d.ts.map

package/dist/key-derivation/bech32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bech32.d.ts","sourceRoot":"","sources":["../../key-derivation/bech32.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,UAAU,CAAC;IAC7B,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AA0CxD;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,aAAa,WAAW,KAAG,MAmBxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,WAoC/C,CAAC"}