@owney/sdk 0.7.27-beta.2 → 0.7.27-beta.3

package/dist/chunk-LUQ4H72X.js

@@ -0,0 +1,542 @@
+// src/lib/token-batch-family.ts
+import {
+  encodeAbiParameters,
+  encodeFunctionData,
+  hashTypedData,
+  isAddress,
+  isAddressEqual,
+  keccak256,
+  parseAbi as parseAbi2,
+  parseTransaction,
+  recoverTransactionAddress,
+  recoverTypedDataAddress,
+  sliceHex,
+  toBytes
+} from "viem";
+
+// src/errors.ts
+var OwneyError = class extends Error {
+  code;
+  details;
+  agentId;
+  constructor(code, message, details, agentId) {
+    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
+    super(`${prefix} ${message}`);
+    this.name = "OwneyError";
+    this.code = code;
+    this.details = details;
+    this.agentId = agentId;
+  }
+};
+var AgentNotFoundError = class extends OwneyError {
+  constructor(agentId, available) {
+    super(
+      "AGENT_NOT_FOUND",
+      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+      { agentId, available },
+      agentId
+    );
+    this.name = "AgentNotFoundError";
+  }
+};
+var NotConnectedError = class extends OwneyError {
+  constructor() {
+    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
+  }
+};
+var AgentChainIncompatibleError = class extends OwneyError {
+  incompatibleAgents;
+  connectedChainId;
+  constructor(incompatibleAgents, connectedChainId) {
+    const details = incompatibleAgents.map(
+      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+    ).join("; ");
+    super(
+      "AGENT_CHAIN_INCOMPATIBLE",
+      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+      { incompatibleAgents, connectedChainId }
+    );
+    this.name = "AgentChainIncompatibleError";
+    this.incompatibleAgents = incompatibleAgents;
+    this.connectedChainId = connectedChainId;
+  }
+};
+
+// src/lib/permit2-batch.ts
+import { parseAbi, hashStruct } from "viem";
+var BATCH_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var ARBITRUM_USDC_ADDRESS = "0xaf88d065e77c8cc2239327c5edb3a432268e5831";
+function supportsSponsoredErc2612(chainId, token) {
+  const expected = chainId === 8453 ? BASE_USDC_ADDRESS : chainId === 42161 ? ARBITRUM_USDC_ADDRESS : void 0;
+  return expected !== void 0 && token.toLowerCase() === expected.toLowerCase();
+}
+var ERC2612_PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var ERC2612_READ_ABI = parseAbi([
+  "function name() view returns (string)",
+  "function version() view returns (string)",
+  "function nonces(address owner) view returns (uint256)"
+]);
+function erc2612TypedData(input) {
+  return {
+    domain: {
+      name: input.permit.tokenName,
+      version: input.permit.tokenVersion,
+      chainId: input.chainId,
+      verifyingContract: input.token
+    },
+    types: ERC2612_PERMIT_TYPES,
+    primaryType: "Permit",
+    message: {
+      owner: input.owner,
+      spender: BATCH_PERMIT2_ADDRESS,
+      value: BigInt(input.permit.value),
+      nonce: BigInt(input.permit.nonce),
+      deadline: BigInt(input.permit.deadline)
+    }
+  };
+}
+var PERMIT_BATCH_TYPES = {
+  PermitBatchWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions[]" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Deposit" }
+  ],
+  Deposit: [{ name: "recipients", type: "address[]" }],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+var PERMIT2_BATCH_ABI = parseAbi([
+  "struct TokenPermissions { address token; uint256 amount; }",
+  "struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }",
+  "struct SignatureTransferDetails { address to; uint256 requestedAmount; }",
+  "function permitWitnessTransferFrom(PermitBatchTransferFrom permit,SignatureTransferDetails[] transferDetails,address owner,bytes32 witness,string witnessTypeString,bytes signature)",
+  "function nonceBitmap(address owner,uint256 wordPos) view returns (uint256)"
+]);
+function batchPermit(b) {
+  return {
+    permitted: b.transfers.map((t) => ({
+      token: b.token,
+      amount: BigInt(t.amount)
+    })),
+    nonce: BigInt(b.nonce),
+    deadline: BigInt(b.deadline)
+  };
+}
+function batchTypedData(b, spender) {
+  return {
+    domain: {
+      name: "Permit2",
+      chainId: b.chainId,
+      verifyingContract: BATCH_PERMIT2_ADDRESS
+    },
+    types: PERMIT_BATCH_TYPES,
+    primaryType: "PermitBatchWitnessTransferFrom",
+    message: {
+      ...batchPermit(b),
+      spender,
+      witness: { recipients: b.transfers.map((t) => t.to) }
+    }
+  };
+}
+var BATCH_WITNESS_TYPE = "Deposit witness)Deposit(address[] recipients)TokenPermissions(address token,uint256 amount)";
+function batchWitness(b) {
+  return hashStruct({
+    types: PERMIT_BATCH_TYPES,
+    primaryType: "Deposit",
+    data: { recipients: b.transfers.map((t) => t.to) }
+  });
+}
+function batchArgs(b) {
+  return [
+    batchPermit(b),
+    b.transfers.map((t) => ({ to: t.to, requestedAmount: BigInt(t.amount) })),
+    b.from,
+    batchWitness(b),
+    BATCH_WITNESS_TYPE,
+    b.signature
+  ];
+}
+
+// src/lib/token-batch-family.ts
+var memory = /* @__PURE__ */ new Map();
+var settled = /* @__PURE__ */ new Map();
+var hashPattern = /^0x[\da-f]{64}$/i;
+var uint = (value) => typeof value === "string" && /^\d{1,78}$/.test(value) && BigInt(value) < 1n << 256n;
+var same = (a, b) => a.toLowerCase() === b.toLowerCase();
+var tokenBatchKey = (s) => `owney.token-batch.v1:${keccak256(toBytes(s.apiKey))}:${s.baseUrl ?? "default"}:${s.chainId}:${s.owner.toLowerCase()}:${s.token.toLowerCase()}`;
+var tokenBatchAuthorizationId = (body, relayer) => keccak256(
+  encodeAbiParameters(
+    [{ type: "address" }, { type: "bytes32" }],
+    [body.from, hashTypedData(batchTypedData(body, relayer))]
+  )
+);
+var tokenBatchStoredBody = (body) => ({
+  ...body,
+  transfers: body.transfers.map(({ to, amount }) => ({ to, amount }))
+});
+function tokenBatchRead(key) {
+  const raw = typeof window === "undefined" ? memory.get(key) : window.localStorage.getItem(key) ?? void 0;
+  return raw && settled.get(key) === raw ? void 0 : raw;
+}
+function tokenBatchWrite(key, value) {
+  if (typeof window === "undefined") memory.set(key, value);
+  else window.localStorage.setItem(key, value);
+  settled.delete(key);
+  if (tokenBatchRead(key) !== value)
+    throw pending("Deposit recovery data could not be saved.");
+}
+function tokenBatchClear(key, expected) {
+  if (tokenBatchRead(key) !== expected) return;
+  try {
+    if (typeof window === "undefined") memory.delete(key);
+    else window.localStorage.removeItem(key);
+  } catch {
+    settled.set(key, expected);
+  }
+}
+function keys() {
+  if (typeof window === "undefined") return [...memory.keys()];
+  const storage = window.localStorage;
+  return Array.from(
+    { length: storage.length },
+    (_, i) => storage.key(i)
+  ).filter((key) => key !== null);
+}
+function pending(message = "The saved deposit could not be verified. Its existing transactions remain pending.") {
+  return new OwneyError("DEPOSIT_IN_PROGRESS", message, {
+    sponsorPending: true,
+    notSubmitted: false,
+    safeToFallback: false
+  });
+}
+var approvalAbi = parseAbi2([
+  "function permit(address owner,address spender,uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s)"
+]);
+function tokenBatchCall(body, phase) {
+  if (phase === "deposit")
+    return {
+      to: BATCH_PERMIT2_ADDRESS,
+      data: encodeFunctionData({
+        abi: PERMIT2_BATCH_ABI,
+        functionName: "permitWitnessTransferFrom",
+        args: batchArgs(body)
+      })
+    };
+  const p = body.erc2612Permit;
+  let v = Number(sliceHex(p.signature, 64));
+  if (v < 27) v += 27;
+  return {
+    to: body.token,
+    data: encodeFunctionData({
+      abi: approvalAbi,
+      functionName: "permit",
+      args: [
+        body.from,
+        BATCH_PERMIT2_ADDRESS,
+        BigInt(p.value),
+        BigInt(p.deadline),
+        v,
+        sliceHex(p.signature, 0, 32),
+        sliceHex(p.signature, 32, 64)
+      ]
+    })
+  };
+}
+async function validateBody(scope, body, relayer) {
+  if (!body || body.chainId !== scope.chainId || !isAddressEqual(body.from, scope.owner) || !isAddressEqual(body.token, scope.token) || !uint(body.nonce) || !uint(body.deadline) || BigInt(body.deadline) === 0n || !Array.isArray(body.transfers) || !body.transfers.length || body.transfers.length > 16 || body.transfers.some(
+    (t) => !isAddress(t.to) || !uint(t.amount) || BigInt(t.amount) === 0n
+  ) || new Set(body.transfers.map((t) => t.to.toLowerCase())).size !== body.transfers.length)
+    throw pending();
+  if (!isAddressEqual(
+    await recoverTypedDataAddress({
+      ...batchTypedData(body, relayer),
+      signature: body.signature
+    }),
+    body.from
+  ))
+    throw pending();
+  const p = body.erc2612Permit;
+  if (p) {
+    if (!supportsSponsoredErc2612(body.chainId, body.token) || !uint(p.nonce) || !uint(p.deadline) || !uint(p.value) || BigInt(p.value) !== (1n << 256n) - 1n || p.deadline !== body.deadline || typeof p.tokenName !== "string" || typeof p.tokenVersion !== "string")
+      throw pending();
+    if (!isAddressEqual(
+      await recoverTypedDataAddress({
+        ...erc2612TypedData({
+          chainId: body.chainId,
+          token: body.token,
+          owner: body.from,
+          permit: p
+        }),
+        signature: p.signature
+      }),
+      body.from
+    ))
+      throw pending();
+  }
+}
+async function validateTokenBatchAttempt(scope, body, attempt, expectedRelayer) {
+  if (!attempt || !["approval", "deposit"].includes(attempt.phase) || !hashPattern.test(attempt.hash) || !uint(attempt.nonce) || !Number.isFinite(attempt.preparedAt) || typeof attempt.submissionAttempted !== "boolean" || attempt.predecessorHash !== void 0 && !hashPattern.test(attempt.predecessorHash))
+    throw pending();
+  if (typeof attempt.serializedTransaction !== "string" || !/^0x(?:[\da-f]{2}){1,32768}$/i.test(attempt.serializedTransaction))
+    throw pending();
+  const serialized = attempt.serializedTransaction;
+  if (!same(keccak256(serialized), attempt.hash)) throw pending();
+  const tx = parseTransaction(serialized), relayer = await recoverTransactionAddress({
+    serializedTransaction: serialized
+  });
+  if (expectedRelayer && !isAddressEqual(relayer, expectedRelayer))
+    throw pending();
+  await validateBody(scope, body, relayer);
+  const call = tokenBatchCall(body, attempt.phase);
+  if (tx.chainId !== body.chainId || !tx.to || !isAddressEqual(tx.to, call.to) || (tx.value ?? 0n) !== 0n || tx.data !== call.data || !Number.isSafeInteger(tx.nonce) || String(tx.nonce) !== attempt.nonce)
+    throw pending();
+  return relayer;
+}
+function terminalOf(value, attempts) {
+  if (!value || !["confirmed", "failed", "expired"].includes(value.kind) || !uint(value.blockNumber))
+    return;
+  if (value.kind === "confirmed" && (!value.txHash || !attempts.some(
+    (a) => a.phase === "deposit" && same(a.hash, value.txHash)
+  )))
+    return;
+  if (value.txHash !== void 0 && !hashPattern.test(value.txHash)) return;
+  return {
+    kind: value.kind,
+    blockNumber: value.blockNumber,
+    ...value.txHash ? { txHash: value.txHash } : {}
+  };
+}
+async function validateFamily(scope, raw) {
+  if (!raw || raw.version !== 1 || !Array.isArray(raw.attempts) || !raw.attempts.length || !raw.current || !isAddress(raw.relayer) || !hashPattern.test(raw.authorizationId))
+    throw pending();
+  if (!same(tokenBatchAuthorizationId(raw.body, raw.relayer), raw.authorizationId))
+    throw pending();
+  const seen = /* @__PURE__ */ new Map();
+  const roots = /* @__PURE__ */ new Set();
+  for (const a of raw.attempts) {
+    await validateTokenBatchAttempt(scope, raw.body, a, raw.relayer);
+    if (seen.has(a.hash.toLowerCase())) throw pending();
+    if (a.predecessorHash) {
+      const predecessor = seen.get(a.predecessorHash.toLowerCase());
+      if (!predecessor || predecessor.phase !== a.phase || BigInt(a.nonce) <= BigInt(predecessor.nonce))
+        throw pending();
+    } else {
+      if (roots.has(a.phase)) throw pending();
+      roots.add(a.phase);
+    }
+    seen.set(a.hash.toLowerCase(), a);
+  }
+  for (const phase of ["approval", "deposit"]) {
+    const current = raw.current[phase];
+    if (current && !raw.attempts.some((a) => a.phase === phase && same(a.hash, current)))
+      throw pending();
+    if (raw.attempts.some((a) => a.phase === phase) && !current)
+      throw pending();
+  }
+  return {
+    ...raw,
+    body: tokenBatchStoredBody(raw.body),
+    terminal: terminalOf(raw.terminal, raw.attempts)
+  };
+}
+async function importBody(scope, body) {
+  const attempts = [];
+  let relayer;
+  for (const phase of ["approval", "deposit"]) {
+    const bytes = phase === "approval" ? body.serializedPermitTransaction : body.serializedTransaction;
+    if (!bytes) continue;
+    const a = {
+      phase,
+      hash: keccak256(bytes),
+      serializedTransaction: bytes,
+      nonce: String(parseTransaction(bytes).nonce),
+      preparedAt: 0,
+      submissionAttempted: true
+    };
+    relayer = await validateTokenBatchAttempt(scope, body, a, relayer);
+    attempts.push(a);
+  }
+  if (!relayer) return;
+  return {
+    version: 1,
+    authorizationId: tokenBatchAuthorizationId(body, relayer),
+    relayer,
+    body: tokenBatchStoredBody(body),
+    attempts,
+    current: Object.fromEntries(attempts.map((a) => [a.phase, a.hash]))
+  };
+}
+function merge(base, incoming) {
+  if (!same(base.authorizationId, incoming.authorizationId)) throw pending();
+  const attempts = base.attempts.map((a) => ({ ...a }));
+  for (const a of incoming.attempts) {
+    const existing = attempts.find((x) => same(x.hash, a.hash));
+    if (existing) existing.submissionAttempted ||= a.submissionAttempted;
+    else attempts.push(a);
+  }
+  return { ...base, attempts };
+}
+async function loadTokenBatchFamily(scope, expectedHash, allowMissing = false) {
+  try {
+    const key = tokenBatchKey(scope), records = /* @__PURE__ */ new Map();
+    for (const k of keys().filter((k2) => k2.startsWith(`${key}:family:`))) {
+      const raw = tokenBatchRead(k);
+      if (!raw) continue;
+      const family = await validateFamily(scope, JSON.parse(raw));
+      if (k !== `${key}:family:${family.authorizationId}`) throw pending();
+      records.set(family.authorizationId, family);
+    }
+    let projectedId;
+    const projection = tokenBatchRead(key);
+    if (projection) {
+      const imported = await importBody(scope, JSON.parse(projection));
+      if (imported) {
+        projectedId = imported.authorizationId;
+        const stored = records.get(projectedId);
+        if (stored)
+          for (const attempt of imported.attempts) {
+            const known = stored.attempts.find(
+              (a) => same(a.hash, attempt.hash)
+            );
+            if (known) attempt.submissionAttempted = known.submissionAttempted;
+          }
+        records.set(
+          projectedId,
+          stored ? await validateFamily(scope, merge(stored, imported)) : imported
+        );
+      }
+    }
+    if (expectedHash) {
+      let found = [...records.values()].filter(
+        (f) => f.attempts.some((a) => same(a.hash, expectedHash))
+      );
+      if (!found.length) {
+        const archive = tokenBatchRead(
+          `${key}:expired:${expectedHash.toLowerCase()}`
+        );
+        if (archive) {
+          const f = await importBody(scope, JSON.parse(archive));
+          if (f?.attempts.some((a) => same(a.hash, expectedHash))) found = [f];
+        }
+      }
+      if (!found.length && allowMissing) return;
+      if (found.length !== 1) throw pending();
+      return found[0];
+    }
+    const active = [...records.values()].filter(
+      (f) => !f.terminal || f.authorizationId === projectedId
+    );
+    if (active.length > 1) throw pending();
+    return active[0];
+  } catch (error) {
+    if (error instanceof OwneyError) throw error;
+    throw pending();
+  }
+}
+async function saveTokenBatchAttempt(scope, body, attempt, assertCurrent = () => {
+}) {
+  try {
+    const relayer = await validateTokenBatchAttempt(scope, body, attempt), id = tokenBatchAuthorizationId(body, relayer), key = tokenBatchKey(scope), sidecar = `${key}:family:${id}`;
+    const prior = await loadTokenBatchFamily(scope);
+    if (prior && prior.authorizationId !== id) throw pending();
+    let family = prior ?? {
+      version: 1,
+      authorizationId: id,
+      relayer,
+      body: tokenBatchStoredBody(body),
+      attempts: [],
+      current: {}
+    };
+    const saved = tokenBatchRead(sidecar);
+    if (saved)
+      family = merge(await validateFamily(scope, JSON.parse(saved)), family);
+    const sameAttempt = family.attempts.find((a) => same(a.hash, attempt.hash));
+    if (sameAttempt)
+      sameAttempt.submissionAttempted ||= attempt.submissionAttempted;
+    else family.attempts.push({ ...attempt });
+    family.current[attempt.phase] = attempt.hash;
+    family.body = { ...tokenBatchStoredBody(body) };
+    for (const phase of ["approval", "deposit"]) {
+      const current = family.attempts.find(
+        (a) => a.hash === family.current[phase]
+      );
+      if (current)
+        family.body[phase === "deposit" ? "serializedTransaction" : "serializedPermitTransaction"] = current.serializedTransaction;
+    }
+    family = await validateFamily(scope, family);
+    if (tokenBatchRead(sidecar) !== saved)
+      throw pending(
+        "Deposit recovery data changed. Retry the existing deposit."
+      );
+    assertCurrent();
+    tokenBatchWrite(sidecar, JSON.stringify(family));
+    assertCurrent();
+    tokenBatchWrite(key, JSON.stringify(family.body));
+    return family;
+  } catch (error) {
+    if (error instanceof OwneyError) throw error;
+    throw pending(
+      "Deposit recovery data could not be saved. The earlier transaction remains tracked."
+    );
+  }
+}
+function finishTokenBatchFamily(scope, family, terminal) {
+  const key = tokenBatchKey(scope), sidecar = `${key}:family:${family.authorizationId}`;
+  try {
+    const saved = tokenBatchRead(sidecar), current = saved ? JSON.parse(saved) : family;
+    if (current.authorizationId !== family.authorizationId) return;
+    if (terminal.kind !== "confirmed" && current.attempts.some(
+      (a) => !family.attempts.some((known) => same(known.hash, a.hash))
+    ))
+      return;
+    const evidence = terminalOf(terminal, current.attempts);
+    if (!evidence) return;
+    tokenBatchWrite(
+      sidecar,
+      JSON.stringify({ ...current, terminal: evidence })
+    );
+    const projected = tokenBatchRead(key);
+    if (projected && tokenBatchAuthorizationId(JSON.parse(projected), family.relayer) === family.authorizationId)
+      tokenBatchClear(key, projected);
+  } catch {
+  }
+}
+
+export {
+  OwneyError,
+  AgentNotFoundError,
+  NotConnectedError,
+  AgentChainIncompatibleError,
+  BATCH_PERMIT2_ADDRESS,
+  supportsSponsoredErc2612,
+  ERC2612_READ_ABI,
+  erc2612TypedData,
+  PERMIT2_BATCH_ABI,
+  batchTypedData,
+  batchArgs,
+  tokenBatchKey,
+  tokenBatchAuthorizationId,
+  tokenBatchStoredBody,
+  tokenBatchRead,
+  tokenBatchWrite,
+  tokenBatchClear,
+  tokenBatchCall,
+  validateTokenBatchAttempt,
+  loadTokenBatchFamily,
+  saveTokenBatchAttempt,
+  finishTokenBatchFamily
+};