@logswap/sdk 0.5.55 → 0.5.57

package/src/onboard.ts

@@ -22,6 +22,23 @@ export const MAX_UINT256 = (1n << 256n) - 1n;
 export const MAX_UINT160 = (1n << 160n) - 1n;
 export const MAX_UINT48 = (1n << 48n) - 1n;
 
+/**
+ * How long a Permit2 allowance to the router lives: 30 days, as Uniswap's own interface does. It
+ * used to be `MAX_UINT48` — never — so a router bug or a compromised router could pull every
+ * approved token from every user indefinitely. A lapsed allowance is re-granted by one more
+ * signature, riding inside the next write ({@link permit2SigCalls}).
+ */
+export const PERMIT2_EXPIRY_SECONDS = 30n * 24n * 3600n;
+/** An allowance that lapses within this window is treated as already lapsed: it could die in flight. */
+const EXPIRY_MARGIN_SECONDS = 3600;
+
+const nowSeconds = () => Math.floor(Date.now() / 1000);
+/** The expiry to grant now. */
+export const permit2Expiry = (): bigint => BigInt(nowSeconds()) + PERMIT2_EXPIRY_SECONDS;
+/** Whether a Permit2 allowance (amount, expiration) covers `need` for long enough to land. */
+export const permit2Covers = (amount: bigint, expiration: number, need: bigint): boolean =>
+  amount >= need && expiration > nowSeconds() + EXPIRY_MARGIN_SECONDS;
+
 const ERC20 = parseAbi([
   "function approve(address spender, uint256 amount) returns (bool)",
   "function allowance(address owner, address spender) view returns (uint256)",
@@ -71,7 +88,7 @@ export async function approvePermit2ForRouter(
   c: LogswapClient,
   token: Address,
   amount: bigint = MAX_UINT160,
-  expiration: bigint = MAX_UINT48,
+  expiration: bigint = permit2Expiry(),
 ): Promise<Hash | null> {
   if (!usesPermit2(c)) return null;
   const { account } = requireWallet(c);
@@ -109,13 +126,13 @@ export async function onboardToken(c: LogswapClient, token: Address, need: bigin
   }
 
   if (usesPermit2(c)) {
-    const [amt] = (await c.public.readContract({
+    const [amt, expiration] = (await c.public.readContract({
       address: c.addresses.permit2!,
       abi: PERMIT2,
       functionName: "allowance",
       args: [address, token, c.addresses.router],
     })) as readonly [bigint, number, number];
-    if (amt < need) {
+    if (!permit2Covers(amt, expiration, need)) {
       const h = await approvePermit2ForRouter(c, token);
       if (h) {
         await c.public.waitForTransactionReceipt({ hash: h });
@@ -150,13 +167,13 @@ export async function checkTokenReadiness(
 
   let needsPermit2Approval = false;
   if (usesPermit2(c)) {
-    const [amt] = (await c.public.readContract({
+    const [amt, expiration] = (await c.public.readContract({
       address: c.addresses.permit2!,
       abi: PERMIT2,
       functionName: "allowance",
       args: [owner, token, c.addresses.router],
     })) as readonly [bigint, number, number];
-    needsPermit2Approval = amt < need;
+    needsPermit2Approval = !permit2Covers(amt, expiration, need);
   }
 
   return { usesPermit2: usesPermit2(c), needsTokenApproval: allowance < need, needsPermit2Approval };
@@ -195,15 +212,15 @@ export async function permit2SigCalls(c: LogswapClient, tokens: Address[]): Prom
   const chainId = await c.public.getChainId();
   const calls: Hex[] = [];
   for (const token of [...new Set(tokens.map((t) => t.toLowerCase() as Address))]) {
-    const [amt, , nonce] = (await c.public.readContract({
+    const [amt, expiration, nonce] = (await c.public.readContract({
       address: c.addresses.permit2!,
       abi: PERMIT2,
       functionName: "allowance",
       args: [owner, token, c.addresses.router],
     })) as readonly [bigint, number, number];
-    if (amt >= 1n << 120n) continue; // effectively infinite already
+    if (permit2Covers(amt, expiration, 1n << 120n)) continue; // effectively unlimited, and not lapsing
     const message = {
-      details: { token, amount: MAX_UINT160, expiration: Number(MAX_UINT48), nonce },
+      details: { token, amount: MAX_UINT160, expiration: Number(permit2Expiry()), nonce },
       spender: c.addresses.router,
       sigDeadline: BigInt(Math.floor(Date.now() / 1000)) + 1800n,
     };

package/src/pools.ts

@@ -31,7 +31,7 @@ export interface PoolState {
   reserveQuote: bigint;
   /** Fee-per-unit-L accumulator: $\phi \cdot \mathrm{TV}(\log p)$. */
   F: bigint;
-  /** Quadratic variation of log-price, $\Sigma = \sum_{\text{swaps}} (\Delta x_{\text{swap}})^2$ — one term per swap (decisions 042). */
+  /** Quadratic variation of log-price, $\Sigma = \sum_{\text{swaps}} (\Delta x_{\text{swap}})^2$ — one term per swap. */
   bigSigma: bigint;
   currentK: bigint;
   protocolOwed: bigint;
@@ -52,7 +52,7 @@ export async function getPool(c: LogswapClient, key: PoolKey): Promise<PoolState
 
 /**
  * The market's fee: the key's `phi` with `0n` resolved to `DEFAULT_FEE`. Constant for the market's
- * life (C version 4, decisions 042 — `phiEff` and the variance kernel before). Reverts for a key
+ * life (C version 4, — `phiEff` and the variance kernel before). Reverts for a key
  * nobody initialized, which `discoverMarkets` relies on to drop a stale indexer's rows.
  */
 export async function phiOf(c: LogswapClient, key: PoolKey): Promise<bigint> {

package/src/write.ts

@@ -13,7 +13,7 @@
  * what you have — but the bound is what ships.
  */
 
-import type { Address, Hash } from "viem";
+import type { Address, Hash, Hex } from "viem";
 import type { LogswapClient } from "./client.js";
 
 /** Disables the deadline check. Deliberate opt-out, never a default. */
@@ -114,6 +114,31 @@ export async function sendRouterWrite(
   return c.wallet!.writeContract({ ...(params as object), gas } as never);
 }
 
+/**
+ * Whether an error is the user saying no in their wallet (EIP-1193 code 4001, viem's
+ * `UserRejectedRequestError`), however deep viem nested it.
+ */
+export function isUserRejection(e: unknown): boolean {
+  const seen = new Set<unknown>();
+  for (let x: unknown = e; x && typeof x === "object" && !seen.has(x); x = (x as { cause?: unknown }).cause) {
+    seen.add(x);
+    const o = x as { name?: string; code?: number };
+    if (o.name === "UserRejectedRequestError" || o.code === 4001) return true;
+  }
+  return false;
+}
+
+/**
+ * The permit signatures are an optimisation: when they cannot be produced (a wallet without
+ * `signTypedData`, a read that failed) the write goes out plain and relies on a standing
+ * allowance. A REJECTED signature is not that — it was swallowed too, and the user who had just
+ * said no was shown a transaction prompt, which then reverted with a Permit2 error that hid why.
+ */
+export function fallBackUnlessRejected(e: unknown): Hex[] {
+  if (isUserRejection(e)) throw e;
+  return [];
+}
+
 /** Simulate a router write and return its decoded result, without sending. */
 export async function simulateRouterWrite<T>(
   c: LogswapClient,
@@ -142,7 +167,7 @@ export async function sendRouterWriteWithPermits(
   pullTokens: Address[],
 ): Promise<Hash> {
   const { permit2SigCalls } = await import("./onboard.js");
-  const sigCalls = await permit2SigCalls(c, pullTokens).catch(() => []);
+  const sigCalls = await permit2SigCalls(c, pullTokens).catch(fallBackUnlessRejected);
   if (sigCalls.length === 0) return sendRouterWrite(c, args);
   const { encodeFunctionData } = await import("viem");
   const inner = encodeFunctionData({ abi: args.abi, functionName: args.functionName, args: args.args } as never);