@lamarge/sdk 0.0.0-stage → 0.1.0

package/dist/maker.d.ts

@@ -0,0 +1,251 @@
+import { type Client } from "./client.ts";
+import type { components } from "./generated/api.ts";
+import { type DeploymentManifest } from "./protocol/deployments.ts";
+import { type FundingSource } from "./protocol/intents.ts";
+import { type QuoteIntent } from "./protocol/protocol.ts";
+import { type Signer } from "./signer.ts";
+import { type SignatureStore } from "./store.ts";
+export type Order = components["schemas"]["Order"];
+export type Credential = components["schemas"]["CredentialCreated"];
+/** An EOA key, or a deployed ERC-1271 delegate whose signature is collected elsewhere (`prepareUnsigned`). */
+export type QuoteSigner = Pick<Signer, "address" | "signTypedData">;
+/** A fill as the event journal shows it, its venues named as in REST fills. */
+export type FeedFill = Omit<components["schemas"]["FillPreview"], "from" | "to"> & {
+    from_venue: string;
+    to_venue: string;
+};
+/** A fill as delivery needs it, from the REST list or the event feed alike. */
+export type DeliveryFill = Pick<components["schemas"]["Fill"], "id" | "role" | "state" | "payment_leg" | "maker_leg" | "to_venue" | "amount_out" | "deliver_by" | "report_by" | "delivery_to" | "delivery_hash" | "payment_verified_at">;
+/** The financial key: provisioning and release of capital only. Never give it to the quoting host. */
+export declare class Maker {
+    readonly client: Client;
+    private account;
+    private operator;
+    private appOrigin;
+    private manifest;
+    private sessionId;
+    /** `operator` and `appOrigin` come from reviewed deployment configuration, never from the API. */
+    constructor(client: Client, account: Signer, operator: string, appOrigin: string, manifest?: DeploymentManifest);
+    login(): Promise<void>;
+    logout(): Promise<void>;
+    balances(): Promise<{
+        setup: components["schemas"]["SetupSteps"];
+        holdings: components["schemas"]["Holdings"];
+        portfolio: components["schemas"]["PortfolioObservation"];
+        venue: components["schemas"]["VenueId"];
+        address: components["schemas"]["Address"];
+        venue_wallet: string | null;
+        equity: string | null;
+        withdrawable: string | null;
+        withdrawal_fee: string | null;
+        withdrawable_estimated: boolean;
+        mode: string | null;
+        has_account: boolean;
+        wallet: string | null;
+        chain_balance: string | null;
+        escrow_balance: string | null;
+        deposit_balance: string | null;
+        deposit_address: components["schemas"]["Address"] | null;
+        read_at: string | null;
+        error: string | null;
+        chain_read_at: components["schemas"]["Timestamp"] | null;
+        chain_error: string | null;
+    }[]>;
+    order(id: string): Promise<{
+        preparation_id: components["schemas"]["Uuid"] | null;
+        capital_pool: boolean;
+        held_in: components["schemas"]["HeldIn"];
+        id: components["schemas"]["Bytes32"];
+        venue: components["schemas"]["VenueId"];
+        receive_venue: components["schemas"]["VenueId"] | null;
+        owner_address: components["schemas"]["Address"];
+        state: components["schemas"]["OrderState"];
+        error: string | null;
+        amount: components["schemas"]["Amount"];
+        held: components["schemas"]["Amount"];
+        escrow_available: components["schemas"]["Amount"];
+        delivery_fee: components["schemas"]["Amount"];
+        revision: components["schemas"]["Cursor"];
+        available_to_quote: components["schemas"]["Amount"];
+        received_by_venue: {
+            venue: components["schemas"]["VenueId"];
+            amount: components["schemas"]["Amount"];
+        }[];
+        quotable: components["schemas"]["Amount"];
+        filled: components["schemas"]["Amount"];
+        last_sequence: number;
+        quote_set: components["schemas"]["QuoteSet"] | null;
+        margin_move: components["schemas"]["MarginMove"] | null;
+        transactions: components["schemas"]["Transaction"][];
+        created_at: components["schemas"]["Timestamp"];
+        updated_at: components["schemas"]["Timestamp"];
+        client_order_id: components["schemas"]["ClientId"];
+        quote_identity_id: components["schemas"]["Uuid"];
+        quote_signer: components["schemas"]["Address"];
+    }>;
+    /**
+     * Links the financial key's own account on `venue`, or `owner`'s, which signs the link message,
+     * then the setup step a maker pool needs: on Aster, approving LaMarge's agent.
+     */
+    link(venue: string, owner?: Signer): Promise<{
+        setup: components["schemas"]["SetupSteps"];
+        venue: components["schemas"]["VenueId"];
+        address: components["schemas"]["Address"];
+        venue_wallet: string | null;
+        linked_at: components["schemas"]["Timestamp"];
+    }>;
+    createCredential(name: string, quoteSigner: string, days?: number): Promise<Credential>;
+    /**
+     * Persist `client_request_id`, and keep `store`: each signed preparation is saved there before its first submission. `owner`,
+     * for a pool held inside its venue (Lighter, Aster), is the dedicated address linked there;
+     * escrow funding always comes from the financial key.
+     */
+    addCapital(input: {
+        venue: string;
+        amount: string;
+        client_request_id: string;
+        funding_source: FundingSource;
+    }, credential: Pick<Credential, "id" | "quote_signer">, store?: SignatureStore, expectedOwner?: string): Promise<Order>;
+    closeOrders(ids: string[]): Promise<Order[]>;
+    waitFor(id: string, states: Order["state"][], timeoutMs?: number): Promise<Order>;
+}
+/** A scoped credential (`mk_`) quotes and cancels only its own orders; this key cannot withdraw capital. */
+export declare class Quoter {
+    readonly client: Client;
+    readonly identity: string;
+    private account;
+    private manifest;
+    private lastRtt;
+    constructor(client: Client, identity: string, account: QuoteSigner, manifest?: DeploymentManifest);
+    /** Each answer's round trip, reported with the next lease. */
+    private timed;
+    order(id: string): Promise<{
+        preparation_id: components["schemas"]["Uuid"] | null;
+        capital_pool: boolean;
+        held_in: components["schemas"]["HeldIn"];
+        id: components["schemas"]["Bytes32"];
+        venue: components["schemas"]["VenueId"];
+        receive_venue: components["schemas"]["VenueId"] | null;
+        owner_address: components["schemas"]["Address"];
+        state: components["schemas"]["OrderState"];
+        error: string | null;
+        amount: components["schemas"]["Amount"];
+        held: components["schemas"]["Amount"];
+        escrow_available: components["schemas"]["Amount"];
+        delivery_fee: components["schemas"]["Amount"];
+        revision: components["schemas"]["Cursor"];
+        available_to_quote: components["schemas"]["Amount"];
+        received_by_venue: {
+            venue: components["schemas"]["VenueId"];
+            amount: components["schemas"]["Amount"];
+        }[];
+        quotable: components["schemas"]["Amount"];
+        filled: components["schemas"]["Amount"];
+        last_sequence: number;
+        quote_set: components["schemas"]["QuoteSet"] | null;
+        margin_move: components["schemas"]["MarginMove"] | null;
+        transactions: components["schemas"]["Transaction"][];
+        created_at: components["schemas"]["Timestamp"];
+        updated_at: components["schemas"]["Timestamp"];
+        client_order_id: components["schemas"]["ClientId"];
+        quote_identity_id: components["schemas"]["Uuid"];
+        quote_signer: components["schemas"]["Address"];
+    }>;
+    lease(ttlSeconds?: number): Promise<{
+        identity_id: components["schemas"]["Uuid"];
+        generation: components["schemas"]["Cursor"];
+        expires_at: components["schemas"]["Timestamp"];
+    }>;
+    cancelAll(): Promise<{
+        identity_id: components["schemas"]["Uuid"];
+        generation: components["schemas"]["Cursor"];
+        orders: number;
+    }>;
+    /** Prepares `order`'s quote set and checks it; signing is the caller's, as for a contract delegate. */
+    prepareUnsigned(order: Order, quotes: QuoteIntent[], size: bigint, validUntil: number): Promise<{
+        expected_revision: components["schemas"]["Cursor"] | null;
+        draft_id: components["schemas"]["Uuid"];
+        sequence: number;
+        valid_until: components["schemas"]["UnixTime"];
+        expires_at: components["schemas"]["UnixTime"];
+        quote_size: components["schemas"]["Amount"];
+        quotes: components["schemas"]["Quote"][];
+        to_sign: components["schemas"]["ToSign"][];
+    } & import("./protocol/protocol.ts").PreparedQuote & {
+        to_sign: import("./protocol/validation.ts").Verified<import("./protocol/protocol.ts").SignItem[]>;
+    }>;
+    prepare(order: Order, quotes: QuoteIntent[], size: bigint, validUntil: number): Promise<{
+        order_id: string;
+        draft_id: string;
+        signature: `0x${string}`;
+    }>;
+    /** All distinct order updates and cancels commit atomically; a cancel is never replayed, as it would void the sequence that follows. */
+    batch(updates: {
+        order_id: string;
+        draft_id: string;
+        signature: string;
+    }[], cancels?: string[]): Promise<{
+        results: {
+            order_id: components["schemas"]["Bytes32"];
+            cancel_epoch: components["schemas"]["Cursor"];
+            sequence: number | null;
+        }[];
+    }>;
+    /** The identity's fills, current and the last final ones. */
+    fills(): Promise<{
+        id: string;
+        take_id: string;
+        role: components["schemas"]["FillRole"];
+        order_id: components["schemas"]["Bytes32"];
+        sequence: number;
+        quote_index: number;
+        swap_id: components["schemas"]["Bytes32"];
+        hashlock: components["schemas"]["Bytes32"];
+        from_venue: components["schemas"]["VenueId"];
+        to_venue: components["schemas"]["VenueId"];
+        amount_out: components["schemas"]["Amount"];
+        amount_in: components["schemas"]["Amount"];
+        payer: components["schemas"]["Address"];
+        maker_owner: components["schemas"]["Address"];
+        maker_recipient: components["schemas"]["Address"];
+        taker_recipient: components["schemas"]["Address"];
+        payment_leg: components["schemas"]["PaymentLeg"];
+        payment_destination: "venue" | "escrow" | null;
+        maker_destination: "venue" | "escrow" | null;
+        signed_at?: string | null;
+        payment_locked_at?: string | null;
+        maker_claimed_at?: string | null;
+        maker_leg: components["schemas"]["MakerLeg"];
+        state: components["schemas"]["FillState"];
+        reason: string | null;
+        pay_by: components["schemas"]["Timestamp"];
+        reveal_by: components["schemas"]["Timestamp"];
+        t1: components["schemas"]["Timestamp"];
+        t2: components["schemas"]["Timestamp"];
+        deliver_by: string | null;
+        report_by: string | null;
+        delivery_to: string | null;
+        delivery_hash: string | null;
+        delivery_fee: components["schemas"]["Amount"];
+        payment_verified_at: string | null;
+        created_at: components["schemas"]["Timestamp"];
+        updated_at: components["schemas"]["Timestamp"];
+        settled_at: string | null;
+        transactions: components["schemas"]["Transaction"][];
+    }[]>;
+    /** Reports the venue transaction delivering a fill (a Lighter hash or an Aster transfer id); the server verifies it before paying the maker. Exact retries return the fill. */
+    deliver(fillId: string, txHash: string): Promise<{
+        fill: components["schemas"]["Fill"];
+    }>;
+    /**
+     * The identity's open fills kept current from its event journal: a snapshot, then only the
+     * changes, pushed over the stream. `fills()` throws until the first snapshot is in.
+     */
+    fillFeed(signal: AbortSignal, log?: (line: string) => void): {
+        done: Promise<void>;
+        fills: () => Promise<FeedFill[]>;
+        deliver: (id: string, hash: string) => Promise<{
+            fill: components["schemas"]["Fill"];
+        }>;
+    };
+}

package/dist/maker.js

@@ -0,0 +1,201 @@
+import { linkAccount, setUpVenue } from "./account.js";
+import { wait } from "./client.js";
+import { errorText } from "./delivery.js";
+import { changes } from "./events.js";
+import { ESCROW_DEPLOYMENTS, requireSigningDomains } from "./protocol/deployments.js";
+import { checkMakerIntent } from "./protocol/intents.js";
+import { checkCloseOrders, checkPreparedQuote, insist, same, VENUE_SETTLED } from "./protocol/protocol.js";
+import { signIn, signOut } from "./session.js";
+import { signItems } from "./signer.js";
+import { signedItems } from "./store.js";
+/** The financial key: provisioning and release of capital only. Never give it to the quoting host. */
+export class Maker {
+    client;
+    account;
+    operator;
+    appOrigin;
+    manifest;
+    sessionId = "";
+    /** `operator` and `appOrigin` come from reviewed deployment configuration, never from the API. */
+    constructor(client, account, operator, appOrigin, manifest = ESCROW_DEPLOYMENTS) {
+        this.client = client;
+        this.account = account;
+        this.operator = operator;
+        this.appOrigin = appOrigin;
+        this.manifest = manifest;
+    }
+    async login() { this.sessionId = (await signIn(this.client, this.account, this.appOrigin)).session_id; }
+    async logout() { if (this.sessionId)
+        await signOut(this.client, this.sessionId); }
+    balances() { return this.client.call("getBalances"); }
+    order(id) { return this.client.call("getOrder", { path: { id } }); }
+    /**
+     * Links the financial key's own account on `venue`, or `owner`'s, which signs the link message,
+     * then the setup step a maker pool needs: on Aster, approving LaMarge's agent.
+     */
+    async link(venue, owner) {
+        const linked = await linkAccount(this.client, this.account, venue, owner ?? this.account);
+        if (venue === "aster")
+            await setUpVenue(this.client, venue, owner ?? this.account, { steps: ["agent"] });
+        return linked;
+    }
+    async createCredential(name, quoteSigner, days = 30) {
+        const credential = await this.client.call("postV1Credentials", { body: { name, quote_signer: quoteSigner, scopes: ["read", "quote", "cancel"], expires_at: Math.floor(Date.now() / 1000) + days * 86_400 } });
+        insist(same(credential.quote_signer, quoteSigner) && credential.scopes.join(",") === "read,quote,cancel");
+        return credential;
+    }
+    /**
+     * Persist `client_request_id`, and keep `store`: each signed preparation is saved there before its first submission. `owner`,
+     * for a pool held inside its venue (Lighter, Aster), is the dedicated address linked there;
+     * escrow funding always comes from the financial key.
+     */
+    async addCapital(input, credential, store, expectedOwner = this.account.address) {
+        insist(Boolean(input.client_request_id), "Provide a persistent client_request_id");
+        insist(same(expectedOwner, this.account.address) || VENUE_SETTLED.has(input.venue), "Escrow capital is funded by the financial key's own account");
+        const [balances, orders] = await Promise.all([this.balances(), this.client.call("getOrders")]);
+        const owner = balances.find(balance => balance.venue === input.venue)?.address;
+        insist(owner && same(owner, expectedOwner), "Link the source account before provisioning");
+        const existingOrder = orders.find(order => order.capital_pool && order.venue === input.venue && order.quote_identity_id === credential.id && same(order.owner_address, owner)) ?? null;
+        const { venue, ...body } = input;
+        const asked = { ...body, quote_identity_id: credential.id };
+        const prepared = await this.client.call("prepareMaker", { path: { venue }, body: asked, retry: true });
+        if (prepared.state === "accepted" || prepared.state === "complete")
+            return prepared.order;
+        insist(prepared.state === "preparing", "Preparation ended; review a new request");
+        const key = `maker:${prepared.id}`;
+        let signatures = signedItems(await store?.load(key));
+        if (!signatures) {
+            checkMakerIntent(prepared, { ...asked, venue }, { owner, quoteSigner: credential.quote_signer, quoteIdentityId: credential.id, operator: this.operator, existingOrder });
+            signatures = await signItems(this.account, prepared.to_sign, this.manifest);
+            await store?.save(key, signatures);
+        }
+        const { order } = await this.client.call("submitMakerSignatures", { path: { id: prepared.id }, body: { signatures }, retry: true });
+        await store?.delete(key);
+        return order;
+    }
+    async closeOrders(ids) {
+        const result = [];
+        for (let start = 0; start < ids.length; start += 50) {
+            const chunk = ids.slice(start, start + 50);
+            const close = await this.client.call("postCloses", { body: { orders: chunk } });
+            if (!close.id)
+                continue;
+            checkCloseOrders(close.to_sign, chunk, this.account.address);
+            const signatures = await signItems(this.account, close.to_sign, this.manifest);
+            result.push(...(await this.client.call("postCloseSignatures", { path: { id: close.id }, body: { signatures }, retry: true })).orders);
+        }
+        return result;
+    }
+    async waitFor(id, states, timeoutMs = 600_000) {
+        const end = Date.now() + timeoutMs;
+        while (Date.now() < end) {
+            const order = await this.order(id);
+            if (states.includes(order.state))
+                return order;
+            if (order.state === "failed")
+                throw new Error(`Order failed: ${order.error}`);
+            await wait(2_000);
+        }
+        throw new Error(`Order ${id} still pending; recover it by the same client_request_id`);
+    }
+}
+/** A scoped credential (`mk_`) quotes and cancels only its own orders; this key cannot withdraw capital. */
+export class Quoter {
+    client;
+    identity;
+    account;
+    manifest;
+    lastRtt;
+    constructor(client, identity, account, manifest = ESCROW_DEPLOYMENTS) {
+        this.client = client;
+        this.identity = identity;
+        this.account = account;
+        this.manifest = manifest;
+        insist(client.token?.startsWith("mk_"), "Use a scoped maker credential");
+    }
+    /** Each answer's round trip, reported with the next lease. */
+    async timed(run) {
+        const started = performance.now();
+        const answer = await run();
+        const completed = performance.now();
+        this.lastRtt = { ms: Math.round(completed - started), at: completed };
+        return answer;
+    }
+    order(id) { return this.timed(() => this.client.call("getOrder", { path: { id } })); }
+    lease(ttlSeconds = 30) {
+        const sample = this.lastRtt;
+        const age = sample ? Math.round(performance.now() - sample.at) : 0;
+        const telemetry = sample && sample.ms <= 60_000 && age <= 120_000 ? { api_rtt_ms: sample.ms, api_rtt_age_ms: age } : {};
+        return this.timed(() => this.client.call("putV1QuoteIdentitiesIdLease", { path: { id: this.identity }, body: { ttl_seconds: ttlSeconds, ...telemetry }, retry: true }));
+    }
+    cancelAll() { return this.timed(() => this.client.call("deleteV1QuoteIdentitiesIdQuotes", { path: { id: this.identity } })); }
+    /** Prepares `order`'s quote set and checks it; signing is the caller's, as for a contract delegate. */
+    async prepareUnsigned(order, quotes, size, validUntil) {
+        insist(order.quote_identity_id === this.identity && same(order.quote_signer, this.account.address) && order.state === "live" && size > 0n && size <= BigInt(order.available_to_quote));
+        insist(quotes.length > 0);
+        const asks = quotes.map(({ recipient: _, ...ask }) => ask);
+        const prepared = await this.timed(() => this.client.call("prepareQuotes", { path: { id: order.id }, body: { valid_until: validUntil, quote_size: String(size), quotes: asks } }));
+        checkPreparedQuote(prepared, order, quotes, validUntil, String(size));
+        requireSigningDomains(prepared.to_sign, this.manifest);
+        return prepared;
+    }
+    async prepare(order, quotes, size, validUntil) {
+        const prepared = await this.prepareUnsigned(order, quotes, size, validUntil);
+        const [signed] = await signItems(this.account, prepared.to_sign, this.manifest);
+        insist(signed, "Nothing to sign");
+        return { order_id: order.id, draft_id: prepared.draft_id, signature: signed.signature };
+    }
+    /** All distinct order updates and cancels commit atomically; a cancel is never replayed, as it would void the sequence that follows. */
+    batch(updates, cancels = []) {
+        insist(updates.length + cancels.length > 0 && updates.length + cancels.length <= 50);
+        return this.timed(() => this.client.call("postV1QuotesBatch", { body: { updates, cancels }, retry: cancels.length === 0 }));
+    }
+    /** The identity's fills, current and the last final ones. */
+    fills() { return this.timed(() => this.client.call("getFills")); }
+    /** Reports the venue transaction delivering a fill (a Lighter hash or an Aster transfer id); the server verifies it before paying the maker. Exact retries return the fill. */
+    deliver(fillId, txHash) {
+        return this.timed(() => this.client.call("submitDelivery", { path: { id: fillId }, body: { tx_hash: txHash }, retry: true }));
+    }
+    /**
+     * The identity's open fills kept current from its event journal: a snapshot, then only the
+     * changes, pushed over the stream. `fills()` throws until the first snapshot is in.
+     */
+    fillFeed(signal, log = console.error) {
+        const current = new Map();
+        let synced = false;
+        // The journal names the venues `from` and `to`; REST fills, `from_venue` and `to_venue`.
+        const put = (fill) => {
+            const { from, to, ...rest } = fill;
+            current.set(fill.id, { ...rest, from_venue: from, to_venue: to });
+        };
+        const done = (async () => {
+            while (!signal.aborted) {
+                try {
+                    for await (const change of changes(this.client, { scope: "private", signal })) {
+                        if ("resync" in change) {
+                            current.clear();
+                            if ("fills" in change.resync)
+                                for (const fill of change.resync.fills)
+                                    put(fill);
+                        }
+                        else
+                            for (const event of change.events)
+                                if (event.kind === "fill.changed" && "role" in event.data)
+                                    put(event.data);
+                        synced = true;
+                    }
+                }
+                catch (error) {
+                    synced = false;
+                    log(`fills: ${errorText(error)}`);
+                    await wait(2_000, signal).catch(() => undefined);
+                }
+            }
+        })();
+        return {
+            done,
+            fills: async () => { insist(synced, "Fills are not synced yet"); return [...current.values()]; },
+            deliver: (id, hash) => this.deliver(id, hash),
+        };
+    }
+}

package/dist/protocol/consents.d.ts

@@ -0,0 +1,82 @@
+import { type SignItem } from "./protocol.ts";
+import { type Verified } from "./validation.ts";
+/** The message `address` signs to be linked under `master`: six lines, naming both, valid ten minutes at most. */
+export declare function checkLinkChallenge(challenge: {
+    message: string;
+    nonce: string;
+    expires_at: string;
+}, address: string, master: string, now?: number): void;
+type FundingRequest = {
+    kind: string;
+    signer: string;
+    chain_id: number;
+};
+type FundingPlan = {
+    venue: string;
+    owner: string;
+    amount: string;
+    deposit: string;
+    withdrawal_amount: string;
+    withdrawal_to: string | null;
+    observed_at: string;
+    payment_setup: string;
+    requests: FundingRequest[];
+};
+/** What a transfer from wallet funds will ask its payer to sign: at most a permit, a margin withdrawal and the payment, on the pinned escrow chain, for this amount. */
+export declare function checkFundingPlan<P extends FundingPlan>(intent: {
+    from: string;
+    payer: string;
+    amount_in: string;
+    funding_plan: P | null;
+}, now?: number): P;
+type PreparedClose = {
+    venue: string;
+    order_id: string;
+    to_margin: boolean;
+    dex: number;
+    nonce: string;
+    deadline: number;
+    to_sign: SignItem[];
+};
+/** One `close_offer` by the owner, in the pinned escrow domain, to the requested destination, good for an hour at most. */
+export declare function checkCloseOffer<P extends PreparedClose>(prepared: P, order: {
+    venue: string;
+    owner: string;
+    order_id: string;
+}, chain: {
+    id: number;
+    token: string;
+    decimals: number;
+    escrow: string;
+}, now?: number, toMargin?: boolean): prepared is P & {
+    to_sign: Verified<P["to_sign"]>;
+};
+type RefundFill = {
+    id: string;
+    role: string;
+    maker_leg: string;
+    payment_leg: string;
+    t2: string;
+    from_venue: string;
+    maker_recipient: string;
+    payer: string;
+    swap_id: string;
+    amount_in: string;
+    hashlock: string;
+    deliver_by?: string | null | undefined;
+    delivery_hash?: string | null | undefined;
+};
+/** The maker of an abandoned fill may give the taker's locked payment back before `t2`. */
+export declare const canRefundPayment: <F extends RefundFill>(fill: F) => boolean;
+/** The one `refund_payment` consent of `fill`, signed by its payment's beneficiary, good until `t2` at most. */
+export declare function checkPaymentRefund<F extends RefundFill, P extends {
+    deadline: number;
+    to_sign: SignItem[];
+}>(fill: F, prepared: P, now?: number): asserts prepared is P & {
+    to_sign: Verified<P["to_sign"]>;
+};
+/** An escrow lock as `locks(owner, offerId, swapId)` returns it: amount, hashlock, recipient, refundAt, state, dex. */
+export type EscrowLock = readonly [bigint, string, string, bigint, number, number];
+/** The payment lock refunds `fill.amount_in` to its payer at `t2`, and the maker's lock, where the destination has one, was never made: consenting gives up nothing delivered. */
+export declare function checkRefundLocks<F extends RefundFill>(fill: F, payment: EscrowLock, maker: EscrowLock | null): void;
+export {};

package/dist/protocol/consents.js

@@ -0,0 +1,78 @@
+import { requireV5Deployment } from "./deployments.js";
+import { CHAINS, checkDeadline, checkEscrowTyped, checkRegistry, insist, same } from "./protocol.js";
+import { required } from "./validation.js";
+/** The message `address` signs to be linked under `master`: six lines, naming both, valid ten minutes at most. */
+export function checkLinkChallenge(challenge, address, master, now = Date.now()) {
+    const lines = challenge.message.split("\n");
+    const expires = Date.parse(challenge.expires_at);
+    insist(lines.length === 6 && lines[0]?.startsWith("LaMarge: link a ") && same(lines[2], `Account: ${address}`) && same(lines[3], `Master account: ${master}`)
+        && lines[4] === `Nonce: ${challenge.nonce}` && lines[5] === `Expires: ${challenge.expires_at}` && expires > now && expires <= now + 10 * 60_000, "Unexpected account-link challenge");
+}
+/** What a transfer from wallet funds will ask its payer to sign: at most a permit, a margin withdrawal and the payment, on the pinned escrow chain, for this amount. */
+export function checkFundingPlan(intent, now = Date.now()) {
+    const plan = required(intent.funding_plan, "Funding details unavailable; try again shortly");
+    const chain = required(CHAINS[intent.from], "Unknown funding venue");
+    requireV5Deployment(chain.id, chain.escrow);
+    insist(plan.venue === intent.from && same(plan.owner, intent.payer) && plan.amount === intent.amount_in
+        && BigInt(plan.deposit) <= BigInt(plan.amount) && BigInt(plan.withdrawal_amount) <= BigInt(plan.amount), "Funding details changed; review the transfer");
+    const age = now - Date.parse(plan.observed_at);
+    insist(age >= -5_000 && age < 120_000, "Funding details expired; review the transfer");
+    insist(plan.withdrawal_to === (BigInt(plan.withdrawal_amount) > 0n ? "signer" : null), "Funding destination differs from the transfer");
+    const kinds = plan.requests.map(request => request.kind);
+    const permit = plan.payment_setup === "required";
+    insist(plan.requests.every(request => same(request.signer, intent.payer) && request.chain_id === chain.id)
+        && kinds.filter(kind => kind === "pay_take").length === 1 && new Set(kinds).size === kinds.length
+        && kinds.every(kind => kind === "permit" || kind === "margin_move" || kind === "pay_take")
+        && kinds.includes("margin_move") === (BigInt(plan.withdrawal_amount) > 0n)
+        && kinds.includes("permit") === permit && (!permit || kinds[0] === "permit" && BigInt(plan.deposit) > 0n), "Funding requests differ from the transfer");
+    return plan;
+}
+/** How long a close signature may be good for, and the clock's margin. */
+const CLOSE_TTL = 3_600 + 60;
+/** Where a release may go on each venue: Hyperliquid's perps or spot, Polymarket's or Aster's account. */
+const DEXES = { hyperliquid: [0, 4_294_967_295], polymarket: [0], aster: [0] };
+/** One `close_offer` by the owner, in the pinned escrow domain, to the requested destination, good for an hour at most. */
+export function checkCloseOffer(prepared, order, chain, now = Date.now() / 1000, toMargin = true) {
+    if (prepared.to_sign.length !== 1)
+        return false;
+    const [item] = prepared.to_sign;
+    if (!item)
+        return false;
+    try {
+        checkRegistry(order.venue, chain);
+        checkEscrowTyped(item.typed_data, order.venue);
+    }
+    catch {
+        return false;
+    }
+    const { primaryType, message } = item.typed_data;
+    return item.kind === "close_offer" && same(item.signer, order.owner) && primaryType === "CloseOffer" && same(message.owner, order.owner)
+        && same(message.offerId, order.order_id) && message.toMargin === toMargin && prepared.to_margin === toMargin
+        && (toMargin ? (DEXES[order.venue] ?? []).includes(prepared.dex) : prepared.dex === 0)
+        && String(message.dex) === String(prepared.dex) && String(message.nonce) === prepared.nonce && String(message.deadline) === String(prepared.deadline)
+        && same(prepared.order_id, order.order_id) && prepared.venue === order.venue && prepared.deadline > now && prepared.deadline <= now + CLOSE_TTL;
+}
+/** The maker of an abandoned fill may give the taker's locked payment back before `t2`. */
+export const canRefundPayment = (fill) => fill.role === "maker" && fill.maker_leg === "ABANDONED" && fill.payment_leg === "LOCKED" && Date.parse(fill.t2) > Date.now();
+/** The one `refund_payment` consent of `fill`, signed by its payment's beneficiary, good until `t2` at most. */
+export function checkPaymentRefund(fill, prepared, now = Date.now() / 1000) {
+    insist(canRefundPayment(fill), "This payment cannot be refunded early");
+    insist(prepared.to_sign.length === 1, "Unexpected refund signatures");
+    const item = required(prepared.to_sign[0]);
+    checkEscrowTyped(item.typed_data, fill.from_venue);
+    const message = item.typed_data.message;
+    insist(item.kind === "refund_payment" && item.fill_id === fill.id && same(item.signer, fill.maker_recipient)
+        && item.typed_data.primaryType === "RefundPayment" && same(message.payer, fill.payer) && same(message.swapId, fill.swap_id)
+        && String(message.deadline) === String(prepared.deadline) && prepared.deadline <= Date.parse(fill.t2) / 1000, "Refund terms changed");
+    checkDeadline(message.deadline, 3600, now);
+}
+/** The payment lock refunds `fill.amount_in` to its payer at `t2`, and the maker's lock, where the destination has one, was never made: consenting gives up nothing delivered. */
+export function checkRefundLocks(fill, payment, maker) {
+    // A fill keeps the settlement it was taken under: delivered inside the venue, it has a deadline.
+    const inVenue = Boolean(fill.deliver_by);
+    insist(inVenue === (maker === null), "Unsupported refund chain");
+    insist(!inVenue || !fill.delivery_hash, "This fill was delivered");
+    insist(payment[4] === 1 && payment[0] === BigInt(fill.amount_in) && same(payment[1], fill.hashlock)
+        && same(payment[2], fill.maker_recipient) && payment[3] === BigInt(Math.floor(Date.parse(fill.t2) / 1000))
+        && (maker === null || maker[4] === 0), "The onchain locks no longer permit this refund");
+}