@lamarge/sdk 0.0.0-stage → 0.1.0

package/dist/generated/api.js

@@ -0,0 +1,281 @@
+export const routes = {
+    "getSiteShareImage": {
+        "path": "/share/v1/{filename}",
+        "method": "GET"
+    },
+    "getTradeShareImage": {
+        "path": "/share/v1/trades/{id}/image.png",
+        "method": "GET"
+    },
+    "getTradeShareMetadata": {
+        "path": "/share/trade",
+        "method": "GET"
+    },
+    "getVenues": {
+        "path": "/v1/venues",
+        "method": "GET"
+    },
+    "postAsterSigningRpc": {
+        "path": "/v1/venues/aster/rpc",
+        "method": "POST"
+    },
+    "getBook": {
+        "path": "/v1/books",
+        "method": "GET"
+    },
+    "getRoute": {
+        "path": "/v1/routes",
+        "method": "GET"
+    },
+    "getTradeProof": {
+        "path": "/v1/trades/{id}/proof",
+        "method": "GET"
+    },
+    "getVolume": {
+        "path": "/v1/volume",
+        "method": "GET"
+    },
+    "getHealth": {
+        "path": "/health",
+        "method": "GET",
+        "accept": [
+            503
+        ]
+    },
+    "getV1Info": {
+        "path": "/v1/info",
+        "method": "GET"
+    },
+    "postAuthChallenge": {
+        "path": "/v1/auth/challenge",
+        "method": "POST"
+    },
+    "postAuthVerify": {
+        "path": "/v1/auth/verify",
+        "method": "POST"
+    },
+    "deleteV1AuthSessionsId": {
+        "path": "/v1/auth/sessions/{id}",
+        "method": "DELETE"
+    },
+    "getMe": {
+        "path": "/v1/me",
+        "method": "GET"
+    },
+    "postLinkChallenge": {
+        "path": "/v1/accounts/link/challenge",
+        "method": "POST"
+    },
+    "getVenueSetup": {
+        "path": "/v1/accounts/{venue}/setup",
+        "method": "GET"
+    },
+    "postVenueSetupStep": {
+        "path": "/v1/accounts/{venue}/setup/{step}",
+        "method": "POST"
+    },
+    "postLink": {
+        "path": "/v1/accounts/link",
+        "method": "POST"
+    },
+    "deleteLink": {
+        "path": "/v1/accounts/{venue}",
+        "method": "DELETE"
+    },
+    "getBalances": {
+        "path": "/v1/balances",
+        "method": "GET"
+    },
+    "getStats": {
+        "path": "/v1/me/stats",
+        "method": "GET"
+    },
+    "getV1MeExposure": {
+        "path": "/v1/me/exposure",
+        "method": "GET"
+    },
+    "prepareMaker": {
+        "path": "/v1/maker/{venue}/prepare",
+        "method": "POST"
+    },
+    "getMakerPreparation": {
+        "path": "/v1/maker/preparations/{id}",
+        "method": "GET"
+    },
+    "cancelMakerPreparation": {
+        "path": "/v1/maker/preparations/{id}",
+        "method": "DELETE"
+    },
+    "submitMakerSignatures": {
+        "path": "/v1/maker/preparations/{id}/signatures",
+        "method": "POST"
+    },
+    "getOrders": {
+        "path": "/v1/orders",
+        "method": "GET"
+    },
+    "getOrder": {
+        "path": "/v1/orders/{id}",
+        "method": "GET"
+    },
+    "putQuotes": {
+        "path": "/v1/orders/{id}/quotes",
+        "method": "PUT"
+    },
+    "deleteQuotes": {
+        "path": "/v1/orders/{id}/quotes",
+        "method": "DELETE"
+    },
+    "prepareQuotes": {
+        "path": "/v1/orders/{id}/quotes/prepare",
+        "method": "POST"
+    },
+    "postV1QuotesBatch": {
+        "path": "/v1/quotes/batch",
+        "method": "POST"
+    },
+    "putV1QuoteIdentitiesIdLease": {
+        "path": "/v1/quote-identities/{id}/lease",
+        "method": "PUT"
+    },
+    "deleteV1QuoteIdentitiesIdQuotes": {
+        "path": "/v1/quote-identities/{id}/quotes",
+        "method": "DELETE"
+    },
+    "postCloses": {
+        "path": "/v1/closes",
+        "method": "POST"
+    },
+    "postCloseSignatures": {
+        "path": "/v1/closes/{id}/signatures",
+        "method": "POST"
+    },
+    "getEscrow": {
+        "path": "/v1/escrow",
+        "method": "GET"
+    },
+    "postEscrowClosePrepare": {
+        "path": "/v1/escrow/close/prepare",
+        "method": "POST"
+    },
+    "postEscrowClose": {
+        "path": "/v1/escrow/close",
+        "method": "POST"
+    },
+    "postTransfer": {
+        "path": "/v1/transfers",
+        "method": "POST"
+    },
+    "getTransfers": {
+        "path": "/v1/transfers",
+        "method": "GET"
+    },
+    "getTransfer": {
+        "path": "/v1/transfers/{id}",
+        "method": "GET"
+    },
+    "cancelTransfer": {
+        "path": "/v1/transfers/{id}",
+        "method": "DELETE"
+    },
+    "prepareTransferWithdrawal": {
+        "path": "/v1/transfers/{id}/withdrawal/prepare",
+        "method": "POST"
+    },
+    "submitTransferWithdrawal": {
+        "path": "/v1/transfers/{id}/withdrawal",
+        "method": "POST"
+    },
+    "postTake": {
+        "path": "/v1/takes",
+        "method": "POST"
+    },
+    "getV1TakesId": {
+        "path": "/v1/takes/{id}",
+        "method": "GET"
+    },
+    "deleteTake": {
+        "path": "/v1/takes/{id}",
+        "method": "DELETE"
+    },
+    "postTakeSignatures": {
+        "path": "/v1/takes/{id}/signatures",
+        "method": "POST"
+    },
+    "preparePaymentRefund": {
+        "path": "/v1/fills/{id}/refund/prepare",
+        "method": "POST"
+    },
+    "submitPaymentRefund": {
+        "path": "/v1/fills/{id}/refund",
+        "method": "POST"
+    },
+    "submitDelivery": {
+        "path": "/v1/fills/{id}/delivery",
+        "method": "POST"
+    },
+    "getFills": {
+        "path": "/v1/fills",
+        "method": "GET"
+    },
+    "postWithdrawalPrepare": {
+        "path": "/v1/withdrawals/prepare",
+        "method": "POST"
+    },
+    "postWithdrawal": {
+        "path": "/v1/withdrawals",
+        "method": "POST"
+    },
+    "postV1Credentials": {
+        "path": "/v1/credentials",
+        "method": "POST"
+    },
+    "deleteV1CredentialsId": {
+        "path": "/v1/credentials/{id}",
+        "method": "DELETE"
+    },
+    "postV1CredentialsIdRotate": {
+        "path": "/v1/credentials/{id}/rotate",
+        "method": "POST"
+    },
+    "getV1OrdersHistory": {
+        "path": "/v1/orders/history",
+        "method": "GET"
+    },
+    "getTakeHistory": {
+        "path": "/v1/takes/history",
+        "method": "GET"
+    },
+    "getV1FillsHistory": {
+        "path": "/v1/fills/history",
+        "method": "GET"
+    },
+    "getV1WithdrawalsHistory": {
+        "path": "/v1/withdrawals/history",
+        "method": "GET"
+    },
+    "getV1TradesHistory": {
+        "path": "/v1/trades/history",
+        "method": "GET"
+    },
+    "getV1Events": {
+        "path": "/v1/events",
+        "method": "GET"
+    },
+    "getV1Snapshot": {
+        "path": "/v1/snapshot",
+        "method": "GET"
+    },
+    "getV1MeEvents": {
+        "path": "/v1/me/events",
+        "method": "GET"
+    },
+    "getV1MeSnapshot": {
+        "path": "/v1/me/snapshot",
+        "method": "GET"
+    },
+    "getV1Stream": {
+        "path": "/v1/stream",
+        "method": "GET"
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { createClient, exchange, LaMargeError, type Answer, type CallArguments, type CallOptions, type OperationAnswer, type OperationInput, type Client, type ClientConfig, type Request, type Transport } from "./client.ts";
+export { retryAfterMs } from "./retry-after.ts";
+export { checkDeployment, signIn, signOut } from "./session.ts";
+export { signItems, signTyped, typedDataRequest, type Hex, type SignedItem, type Signer, type TypedDataRequest } from "./signer.ts";
+export type { components, operations, paths } from "./generated/api.ts";
+export { linkAccount, permitDone, setUpVenue, submitPermit } from "./account.ts";
+export { changes, type Change, type ChangeOptions, type EventPage, type Snapshot, type SocketConstructor } from "./events.ts";
+export { fresh, FRESH_MS, prefunded, sweepable } from "./funds.ts";
+export { memoryStore, type SignatureStore } from "./store.ts";
+export { checkQuote, MAX_PARTS, minimumTake, QuoteUnavailable, sweep, type Sweep } from "./book.ts";
+export { take, type Balance, type Fill, type TakeInput, type TakeOptions } from "./take.ts";
+export { transfer, TransferPending, unsignedReservation, type Funding, type TransferIntent, type TransferOptions, type TransferRequest, type TransferStage } from "./transfer.ts";
+export { errorText, Refused, VenueDeliverer, type DeliveryJournal, type FillSource, type Log } from "./delivery.ts";
+export { Maker, Quoter, type Credential, type DeliveryFill, type FeedFill, type Order, type QuoteSigner } from "./maker.ts";
+export { checkEscrowLocks, refundPayment, withdraw, type ChainReaders, type RefundFill, type Withdrawal, type WithdrawalRequest } from "./withdraw.ts";

package/dist/index.js

@@ -0,0 +1,14 @@
+export { createClient, exchange, LaMargeError } from "./client.js";
+export { retryAfterMs } from "./retry-after.js";
+export { checkDeployment, signIn, signOut } from "./session.js";
+export { signItems, signTyped, typedDataRequest } from "./signer.js";
+export { linkAccount, permitDone, setUpVenue, submitPermit } from "./account.js";
+export { changes } from "./events.js";
+export { fresh, FRESH_MS, prefunded, sweepable } from "./funds.js";
+export { memoryStore } from "./store.js";
+export { checkQuote, MAX_PARTS, minimumTake, QuoteUnavailable, sweep } from "./book.js";
+export { take } from "./take.js";
+export { transfer, TransferPending, unsignedReservation } from "./transfer.js";
+export { errorText, Refused, VenueDeliverer } from "./delivery.js";
+export { Maker, Quoter } from "./maker.js";
+export { checkEscrowLocks, refundPayment, withdraw } from "./withdraw.js";

package/dist/lighter.d.ts

@@ -0,0 +1,92 @@
+import { VenueDeliverer, type DeliveryJournal, type FillSource, type Log } from "./delivery.ts";
+import type { DeliveryFill } from "./maker.ts";
+import type { Signer } from "./signer.ts";
+/** `max_fee`: the most Lighter may charge per transfer, in USDC base units; 0 unless set. */
+export type LighterConfig = {
+    api: string;
+    chain_id: number;
+    account_index: number;
+    api_key_index: number;
+    max_fee?: number;
+};
+/**
+ * A delivery's signed transaction, persisted before its first send. `attempted` is set before
+ * any send, `sent` once Lighter acknowledged or knows it. `outcome` once settled: `reported` to
+ * LaMarge; `failed`, LaMarge will not take it; `refused` by Lighter on the first send; `dropped`,
+ * it never executes (not attempted before the deadline, failed on Lighter, or expired).
+ * Refused and dropped transfers leave their nonce to Lighter's count.
+ */
+export type Delivery = {
+    fill_id: string;
+    tx_hash: string;
+    tx_type: number;
+    tx_info: string;
+    nonce: number;
+    expires_at: number;
+    amount: string;
+    fee: number;
+    to: number;
+    attempted: boolean;
+    sent: boolean;
+    outcome?: "reported" | "failed" | "dropped" | "refused";
+    created_at: string;
+};
+export type DeliveryStore = DeliveryJournal<Delivery>;
+/** A transfer as Lighter's signers take it (`signTransfer` of lighter-ts-sdk's wallet, or Lighter's Go signer). */
+export type LighterTransferParams = {
+    toAccountIndex: number;
+    asset_id: number;
+    is_spot_account: boolean;
+    from_is_spot_account: boolean;
+    usdcAmount: number;
+    fee: number;
+    memo: string;
+    skipNonce: number;
+    nonce: number;
+    apiKeyIndex: number;
+    accountIndex: number;
+};
+/**
+ * The pool account's API key, held by the application: Lighter signs with its own scheme, in Go
+ * or WebAssembly, so the SDK never loads a signer nor sees the key.
+ */
+export interface LighterSigner {
+    /** A token authenticating the account's reads, as `createAuthTokenWithExpiry` returns it. */
+    authToken(): Promise<string>;
+    signTransfer(params: LighterTransferParams): Promise<{
+        txType: number;
+        txInfo: string;
+        txHash: string;
+        messageToSign?: string | undefined;
+        error?: string | undefined;
+    }>;
+}
+export declare class LighterDeliverer extends VenueDeliverer<Delivery> {
+    readonly config: LighterConfig;
+    private signer;
+    private owner;
+    /** When each pending transfer's status may be read again: Lighter allows 60 reads a minute. */
+    private readAt;
+    /** Transfers seen executed: their status is not read again. */
+    private executed;
+    /** Times of this bot's requests to Lighter within the last minute. */
+    private requests;
+    /** `signer` holds the pool account's API key; `owner`, its owner's key, signs each transfer to another owner's account. */
+    constructor(config: LighterConfig, signer: LighterSigner, owner: Pick<Signer, "signMessage">, store: DeliveryStore, now?: () => number);
+    /** One request to Lighter, within the minute's budget. */
+    private spend;
+    private get;
+    /** Lighter's status of a transaction; null only when Lighter answers that it does not know it. Any other answer throws: the delivery stays pending. */
+    status(txHash: string): Promise<number | null>;
+    /** Signs the fill's transfer at `nonce`: API key signature, then the owner's wallet signature of the message Lighter requires for another owner's account. */
+    sign(fill: DeliveryFill, nonce: number): Promise<Delivery>;
+    /** Sends persisted bytes; Lighter accepts a nonce once, so a resend after a crash cannot pay twice. */
+    send(delivery: Delivery): Promise<void>;
+    /**
+     * Signs at most one new fill, and only while no transfer is of unknown outcome: one unresolved
+     * nonce at a time, never reused for another fill.
+     */
+    protected deliver(quoter: FillSource, due: DeliveryFill[], deliveries: Record<string, Delivery>, log: Log): Promise<boolean>;
+    /** Moves one persisted delivery forward; false while its outcome on Lighter is unknown. */
+    protected settle(quoter: FillSource, delivery: Delivery, fill: DeliveryFill | undefined, deliveries: Record<string, Delivery>, log: Log): Promise<boolean>;
+}

package/dist/lighter.js

@@ -0,0 +1,206 @@
+// Delivery inside Lighter: one internal transfer per fill, signed with the account's API key
+// and its owner's wallet key, persisted durably before it is sent and never signed twice.
+import { errorText, Refused, VenueDeliverer } from "./delivery.js";
+import { fillMemo, USDC_ASSET } from "./protocol/lighter.js";
+import { insist } from "./protocol/protocol.js";
+import { record } from "./protocol/validation.js";
+// Lighter transaction status: 0 failed, 1 pending, 2 executed, 3 final (minutes after 2);
+// above 3, failed.
+const TRANSFER = 12, FAILED = 0, EXECUTED = 2, FINAL = 3;
+/** No transfer is first sent closer than this to its deadline. This bot's signer cannot make the
+ * transaction expire at `deliver_by`, and an execution after the deadline is the maker's loss. */
+const SEND_MARGIN_MS = 60_000;
+/** A Standard Lighter account allows 60 requests a minute, reads and sends alike; this bot makes at most 50. */
+const REQUESTS_PER_MINUTE = 50;
+export class LighterDeliverer extends VenueDeliverer {
+    config;
+    signer;
+    owner;
+    /** When each pending transfer's status may be read again: Lighter allows 60 reads a minute. */
+    readAt = new Map();
+    /** Transfers seen executed: their status is not read again. */
+    executed = new Set();
+    /** Times of this bot's requests to Lighter within the last minute. */
+    requests = [];
+    /** `signer` holds the pool account's API key; `owner`, its owner's key, signs each transfer to another owner's account. */
+    constructor(config, signer, owner, store, now = () => Date.now()) {
+        super("lighter", SEND_MARGIN_MS, store, now);
+        this.config = config;
+        this.signer = signer;
+        this.owner = owner;
+    }
+    /** One request to Lighter, within the minute's budget. */
+    spend() {
+        const now = this.now();
+        this.requests = this.requests.filter(at => now - at < 60_000);
+        if (this.requests.length >= REQUESTS_PER_MINUTE)
+            throw new Error("Lighter request budget spent for this minute");
+        this.requests.push(now);
+    }
+    async get(path, authorization) {
+        this.spend();
+        const response = await fetch(`${this.config.api}/api/v1/${path}`, { headers: { accept: "application/json", ...(authorization ? { authorization } : {}) }, signal: AbortSignal.timeout(10_000) });
+        const answer = await response.json();
+        const body = record(answer);
+        if (!response.ok && body.code !== 21500)
+            throw new Error(`Lighter ${path}: HTTP ${response.status} ${typeof body.message === "string" ? body.message : ""}`);
+        return body;
+    }
+    /** Lighter's status of a transaction; null only when Lighter answers that it does not know it. Any other answer throws: the delivery stays pending. */
+    async status(txHash) {
+        const tx = await this.get(`tx?by=hash&value=${encodeURIComponent(txHash)}`);
+        if (tx.code === 21500)
+            return null;
+        if (tx.code !== 200 || typeof tx.status !== "number" || !Number.isInteger(tx.status))
+            throw new Error(`Lighter answered no status for ${txHash}`);
+        return tx.status;
+    }
+    /** Signs the fill's transfer at `nonce`: API key signature, then the owner's wallet signature of the message Lighter requires for another owner's account. */
+    async sign(fill, nonce) {
+        // The taker's account index, in decimal.
+        const to = Number(fill.delivery_to);
+        insist(fill.to_venue === "lighter" && /^\d+$/.test(fill.delivery_to ?? "") && Number.isSafeInteger(to), "Not a Lighter delivery");
+        // The sending account's fee, in base units, charged on top of the amount; Lighter refuses
+        // a transfer whose fee differs. Read with the account's token, as Lighter documents it.
+        const token = await this.signer.authToken();
+        const fee = await this.get(`transferFeeInfo?account_index=${this.config.account_index}&to_account_index=${to}&auth=${encodeURIComponent(token)}`, token);
+        const usdcFee = Number(fee.transfer_fee_usdc);
+        insist(fee.code === 200 && Number.isSafeInteger(usdcFee) && usdcFee >= 0, "Unexpected Lighter transfer fee");
+        insist(usdcFee <= (this.config.max_fee ?? 0), `Lighter charges this account ${usdcFee} per transfer, above LIGHTER_MAX_FEE`);
+        const signed = await this.signer.signTransfer({ toAccountIndex: to, asset_id: USDC_ASSET, is_spot_account: false, from_is_spot_account: false, usdcAmount: Number(fill.amount_out), fee: usdcFee, memo: `0x${fillMemo(fill.id)}`, skipNonce: 0, nonce, apiKeyIndex: this.config.api_key_index, accountIndex: this.config.account_index });
+        if (signed.error)
+            throw new Error(`Lighter signer: ${signed.error}`);
+        insist(signed.txType === TRANSFER && signed.messageToSign, "Unexpected Lighter transaction");
+        const parsed = JSON.parse(signed.txInfo);
+        const info = record(parsed);
+        insist(info.ToAccountIndex === to && info.FromAccountIndex === this.config.account_index && info.Amount === Number(fill.amount_out) && info.USDCFee === usdcFee && info.AssetIndex === USDC_ASSET && info.ToRouteType === 0 && info.Nonce === nonce && typeof info.ExpiredAt === "number", "The signed transfer differs from the fill");
+        info.L1Sig = await this.owner.signMessage({ message: signed.messageToSign });
+        return { fill_id: fill.id, tx_hash: signed.txHash, tx_type: signed.txType, tx_info: JSON.stringify(info), nonce, expires_at: Number(info.ExpiredAt), amount: fill.amount_out, fee: usdcFee, to, attempted: false, sent: false, created_at: new Date(this.now()).toISOString() };
+    }
+    /** Sends persisted bytes; Lighter accepts a nonce once, so a resend after a crash cannot pay twice. */
+    async send(delivery) {
+        const params = new URLSearchParams({ tx_type: String(delivery.tx_type), tx_info: delivery.tx_info, account_index: String(this.config.account_index), api_key_index: String(this.config.api_key_index), price_protection: "false" });
+        this.spend();
+        const response = await fetch(`${this.config.api}/api/v1/sendTx`, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" }, body: params, signal: AbortSignal.timeout(15_000) });
+        const answer = await response.json().catch(() => ({}));
+        const body = record(answer);
+        if (body.code !== 200) {
+            // Already known by hash: an earlier send landed.
+            if ((await this.status(delivery.tx_hash)) !== null)
+                return;
+            const reason = `Lighter refused the transfer: ${typeof body.message === "string" ? body.message : `HTTP ${response.status}`}`;
+            // An answered refusal is final; an overloaded or failing API may still take the bytes.
+            if (response.status >= 400 && response.status < 500 && response.status !== 429 && typeof body.code === "number")
+                throw new Refused(reason);
+            throw new Error(reason);
+        }
+        insist(!body.tx_hash || body.tx_hash === delivery.tx_hash, "Lighter answered another transaction hash");
+    }
+    /**
+     * Signs at most one new fill, and only while no transfer is of unknown outcome: one unresolved
+     * nonce at a time, never reused for another fill.
+     */
+    async deliver(quoter, due, deliveries, log) {
+        const next = due[0];
+        if (!next)
+            return true;
+        const { nonce: remote } = await this.get(`nextNonce?account_index=${this.config.account_index}&api_key_index=${this.config.api_key_index}`);
+        insist(typeof remote === "number" && Number.isSafeInteger(remote), "Lighter answered no nonce");
+        // Lighter's next nonce, or one past the last transfer it may know, whichever is higher.
+        const known = Object.values(deliveries).filter(delivery => (delivery.attempted || delivery.sent) && delivery.outcome !== "dropped" && delivery.outcome !== "refused").map(delivery => delivery.nonce + 1);
+        const delivery = await this.sign(next, Math.max(remote, ...known));
+        deliveries[next.id] = delivery;
+        await this.store.save(deliveries);
+        try {
+            return await this.settle(quoter, delivery, next, deliveries, log);
+        }
+        catch (error) {
+            log(`${next.id}: ${errorText(error)}`);
+            return false;
+        }
+    }
+    /** Moves one persisted delivery forward; false while its outcome on Lighter is unknown. */
+    async settle(quoter, delivery, fill, deliveries, log) {
+        if (!this.awaits(fill) || fill.delivery_hash === delivery.tx_hash) {
+            // The fill is final, or settled otherwise: nothing left to report for this transfer.
+            delivery.outcome = fill?.delivery_hash === delivery.tx_hash ? "reported" : "failed";
+            await this.store.save(deliveries);
+            log(`${delivery.fill_id}: fill no longer awaits this delivery`);
+            return true;
+        }
+        const id = delivery.fill_id;
+        if (!this.reportDue(id))
+            return true;
+        // Back off between reads and sends whatever the outcome, failures included.
+        if (!this.executed.has(id) && !this.turn(this.readAt, id))
+            return false;
+        let status = this.executed.has(id) ? EXECUTED : await this.status(delivery.tx_hash);
+        if (status !== null && !delivery.sent) {
+            // Lighter knows it, whatever became of the acknowledgement: its nonce is spent.
+            delivery.sent = true;
+            await this.store.save(deliveries);
+        }
+        if (status === null && !delivery.sent) {
+            const deadline = fill.deliver_by ? Date.parse(fill.deliver_by) : 0;
+            if (deadline - this.now() > SEND_MARGIN_MS) {
+                // Recorded before the request: a lost answer never lets these bytes be dropped as unsent.
+                const first = !delivery.attempted;
+                delivery.attempted = true;
+                await this.store.save(deliveries);
+                try {
+                    await this.send(delivery);
+                }
+                catch (error) {
+                    // Only a first send's refusal is final: after a lost answer, the earlier send may
+                    // still execute, and the resend's refusal says nothing of it.
+                    if (!(error instanceof Refused) || !first)
+                        throw error;
+                    // Never executed: the fill is left to its refund rather than signed again.
+                    delivery.outcome = "refused";
+                    await this.store.save(deliveries);
+                    log(`${delivery.fill_id}: ${error.message}`);
+                    return true;
+                }
+                delivery.sent = true;
+                await this.store.save(deliveries);
+                log(`${delivery.fill_id}: transfer ${delivery.tx_hash} sent`);
+                status = await this.status(delivery.tx_hash);
+            }
+            else if (!delivery.attempted) {
+                // Never sent in time: the bytes stay unsent and their nonce is free again.
+                delivery.outcome = "dropped";
+                await this.store.save(deliveries);
+                log(`${delivery.fill_id}: too close to the delivery deadline, transfer not sent`);
+                return true;
+            }
+        }
+        if (status !== null && status >= EXECUTED && status <= FINAL) {
+            this.executed.add(id);
+            this.readAt.delete(id);
+        }
+        if (status === FAILED || status !== null && status > FINAL) {
+            // Never executes; Lighter knows it, so its next nonce accounts for it.
+            delivery.outcome = "dropped";
+            await this.store.save(deliveries);
+            log(`${delivery.fill_id}: transfer ${delivery.tx_hash} failed (status ${status})`);
+            return true;
+        }
+        if (status === null || status < EXECUTED) {
+            // Unknown to Lighter, or not executed, past its own expiry: it can no longer execute.
+            if (this.now() > delivery.expires_at + 60_000) {
+                delivery.outcome = "dropped";
+                await this.store.save(deliveries);
+                log(`${delivery.fill_id}: transfer expired without executing (status ${status})`);
+                return true;
+            }
+            return false;
+        }
+        // Executed on Lighter, its nonce spent: reported until the server takes it or never will.
+        const outcome = await this.report(quoter, id, delivery.tx_hash, log);
+        if (outcome) {
+            delivery.outcome = outcome;
+            await this.store.save(deliveries);
+        }
+        return true;
+    }
+}