@lamarge/sdk 0.0.0-stage → 0.1.0

package/dist/withdraw.js

@@ -0,0 +1,122 @@
+import { LaMargeError } from "./client.js";
+import { checkPaymentRefund, checkRefundLocks } from "./protocol/consents.js";
+import { CHAINS, checkWithdrawal, escrowOf, insist, same } from "./protocol/protocol.js";
+import { address, array, hex, record, required } from "./protocol/validation.js";
+import { signItems, signTyped } from "./signer.js";
+import { exclusive, memoryStore, typedData } from "./store.js";
+/**
+ * One withdrawal's signature, stored under `key` (with `context`) before its first submission and
+ * submitted again after a restart; a stored one is checked at its own signing time. The caller
+ * decides when the record may go.
+ */
+export async function submitWithdrawal(options) {
+    const { key, venue, signer, destination, amount, store, signal } = options;
+    const stored = await store.load(key);
+    let saved = stored === undefined || record(stored).typed === undefined ? undefined : { typed: typedData(record(stored).typed), signature: hex(record(stored).signature) };
+    if (!saved) {
+        const typed = await options.prepare();
+        checkWithdrawal(typed, venue, signer.address, destination, amount);
+        saved = { typed, signature: await signTyped(signer, typed) };
+        signal?.throwIfAborted();
+        await store.save(key, { ...options.context, ...saved });
+    }
+    const message = saved.typed.message;
+    const signedAt = venue === "hyperliquid" ? Number(message.nonce) / 1000 : Number(message.ts);
+    checkWithdrawal(saved.typed, venue, signer.address, destination, amount, signedAt);
+    const kept = { ...options.context, ...saved };
+    return { result: await options.submit(saved.typed, saved.signature), saved: kept };
+}
+/** A withdrawal read back from a store, in the API's shape, or refused. */
+function withdrawalOf(value) {
+    const row = record(value);
+    const text = (name) => { const field = row[name]; insist(typeof field === "string", "Unreadable stored withdrawal"); return field; };
+    const optional = (name) => row[name] === null ? null : text(name);
+    return { id: text("id"), venue: text("venue"), amount: text("amount"), destination: text("destination"), state: text("state"),
+        venue_ref: optional("venue_ref"), error: optional("error"), created_at: text("created_at"), relayed_at: optional("relayed_at") };
+}
+const FINAL = new Set(["relayed", "refused"]);
+/**
+ * Withdraws exactly `amount` from the signer's Hyperliquid or Polymarket account. Its signature
+ * and outcome stay in `store` under `id`: running the same request again returns the outcome or
+ * submits the same signature, and a refused one asks for a new id. Aster relays a withdrawal in a
+ * second envelope this flow does not sign yet.
+ */
+export async function withdraw(client, signer, request, options = {}) {
+    const { id, venue, amount, to } = request;
+    const { store = memoryStore(), signal } = options;
+    insist(venue === "hyperliquid" || venue === "polymarket", `Withdrawals from ${venue} are not supported here`);
+    const key = `withdrawal:${id}`;
+    return exclusive(store, key, async () => {
+        const context = { venue, amount: amount.toString(), to, signer: signer.address.toLowerCase() };
+        const stored = await store.load(key);
+        if (stored !== undefined) {
+            const known = record(stored);
+            insist(Object.entries(context).every(([name, value]) => known[name] === value), `Withdrawal ${id} names another withdrawal`);
+            if (typeof known.refused === "string")
+                throw new Error(`Withdrawal ${id} was refused (${known.refused}); use a new id`);
+            const outcome = known.result === undefined ? undefined : withdrawalOf(known.result);
+            // Queued, submitting or unknown: the same signature, submitted again, reads the current state.
+            if (outcome && FINAL.has(outcome.state))
+                return outcome;
+        }
+        const balance = (await client.call("getBalances", { signal })).find(row => row.venue === venue);
+        insist(balance && same(balance.address, signer.address), "Linked account changed; refresh before signing");
+        const destination = required(to === "wallet" ? balance.venue_wallet : signer.address, "No linked destination wallet");
+        try {
+            const { result, saved } = await submitWithdrawal({
+                key, context, venue, signer, destination, amount, store, signal,
+                prepare: async () => (await client.call("postWithdrawalPrepare", { body: { venue, amount: amount.toString(), to }, signal })).typed_data,
+                submit: (typed, signature) => client.call("postWithdrawal", { body: { venue, typed_data: typed, signature }, signal, retry: true }),
+            });
+            await store.save(key, { ...saved, result });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof LaMargeError && (error.code === "VENUE_REJECTED" || error.code === "WITHDRAWAL_EXPIRED"))
+                await store.save(key, { ...record(await store.load(key) ?? {}), refused: error.code });
+            throw error;
+        }
+    });
+}
+const LOCKS = [{ type: "function", name: "locks", stateMutability: "view",
+        inputs: [{ name: "owner", type: "address" }, { name: "offerId", type: "bytes32" }, { name: "swapId", type: "bytes32" }],
+        outputs: [{ name: "amount", type: "uint256" }, { name: "hashlock", type: "bytes32" }, { name: "recipient", type: "address" }, { name: "refundAt", type: "uint64" }, { name: "state", type: "uint8" }, { name: "dex", type: "uint32" }] }];
+const DIGEST = [{ type: "function", name: "refundPaymentDigest", stateMutability: "view",
+        inputs: [{ name: "consent", type: "tuple", components: [{ name: "payer", type: "address" }, { name: "swapId", type: "bytes32" }, { name: "deadline", type: "uint256" }] }],
+        outputs: [{ type: "bytes32" }] }];
+const ZERO = `0x${"0".repeat(64)}`;
+function lockOf(value) {
+    const fields = array(value);
+    insist(fields.length === 6, "Unreadable escrow lock");
+    const [amount, hashlock, recipient, refundAt, state, dex] = fields;
+    insist(typeof amount === "bigint" && typeof hashlock === "string" && typeof recipient === "string" && typeof refundAt === "bigint" && typeof state === "number" && typeof dex === "number", "Unreadable escrow lock");
+    return [amount, hashlock, recipient, refundAt, state, dex];
+}
+/**
+ * The pinned contracts, read directly: the payment lock at a finalized block, the maker's lock at
+ * the latest, where the destination has one, and the consent digest, which an old ABI cannot
+ * answer. A server's label cannot authorize giving up a payment for capital locked or delivered.
+ */
+export async function checkEscrowLocks(fill, deadline, readers) {
+    const reader = (venue) => required(readers[required(CHAINS[venue], "Unknown venue").id], `No reader for ${venue}'s chain`);
+    const escrow = (venue) => address(escrowOf(venue));
+    const [payment, maker] = await Promise.all([
+        reader(fill.from_venue).readContract({ address: escrow(fill.from_venue), abi: LOCKS, functionName: "locks", args: [address(fill.payer), ZERO, hex(fill.swap_id)], blockTag: "finalized" }),
+        fill.deliver_by ? null : reader(fill.to_venue).readContract({ address: escrow(fill.to_venue), abi: LOCKS, functionName: "locks", args: [address(fill.maker_owner), hex(fill.order_id), hex(fill.swap_id)], blockTag: "latest" }),
+        // An old ABI cannot answer the consent digest: the call fails.
+        reader(fill.from_venue).readContract({ address: escrow(fill.from_venue), abi: DIGEST, functionName: "refundPaymentDigest", args: [{ payer: address(fill.payer), swapId: hex(fill.swap_id), deadline: BigInt(deadline) }] }),
+    ]);
+    checkRefundLocks(fill, lockOf(payment), maker === null ? null : lockOf(maker));
+}
+/**
+ * As the maker of an abandoned fill, gives the taker's locked payment back before `t2`. Without a
+ * reader of each chain the fill touches, nothing is signed.
+ */
+export async function refundPayment(client, signer, fill, readers, signal) {
+    const prepared = await client.call("preparePaymentRefund", { path: { id: fill.id }, signal });
+    checkPaymentRefund(fill, prepared);
+    await checkEscrowLocks(fill, prepared.deadline, readers);
+    const [signed] = await signItems(signer, prepared.to_sign);
+    await checkEscrowLocks(fill, prepared.deadline, readers);
+    await client.call("submitPaymentRefund", { path: { id: fill.id }, body: { deadline: prepared.deadline, signature: required(signed).signature }, signal, retry: true });
+}

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@lamarge/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "TypeScript client for the LaMarge API: sign-in, transfers, takes and market making, with every signature checked first.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.12"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol/index.d.ts",
+      "default": "./dist/protocol/index.js"
+    },
+    "./aster": {
+      "types": "./dist/aster.d.ts",
+      "default": "./dist/aster.js"
+    },
+    "./lighter": {
+      "types": "./dist/lighter.d.ts",
+      "default": "./dist/lighter.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*"
+  ],
+  "scripts": {
+    "api:generate": "bun run scripts/generate-api.ts",
+    "api:check": "bun run scripts/generate-api.ts --check",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "check": "bun run api:check && bun run typecheck && bun test && bun run build && bun run check:package",
+    "check:package": "bun run scripts/check-package.ts"
+  },
+  "peerDependencies": {
+    "viem": "^2.38.0"
+  },
+  "peerDependenciesMeta": {
+    "viem": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@types/bun": "^1.4.2",
+    "openapi-typescript": "^7.13.0",
+    "publint": "0.3.25",
+    "typescript": "^5.9.0",
+    "viem": "2.56.9"
+  }
+}