@catena/sdk 0.0.0-bootstrap.0 → 0.4.0

package/dist/client.d.mts

@@ -0,0 +1,3 @@
+import { t as InvalidKeyError } from "./keypair-BjMJtI3-.mjs";
+import { $ as X402SignedOffer, A as ExtensibleString, B as OnchainNetworkInput, C as COUNTERPARTY_RULE_MODES, D as CounterpartiesResponse, E as CounterpartiesParams, F as Movement, G as Policy, H as POLICY_OVERRIDE_CAPABILITIES, I as MppAction, J as WalletCounterpartyRail, K as SEND_METHODS, L as MppChallenge, M as IntentAction, N as IntentResult, O as Counterparty, P as MOVEMENT_NEXT_STEPS, Q as AppInfo, R as MppResource, S as COUNTERPARTY_ACTIONS, T as CROSS_CHAIN_STATES, U as POLICY_RULE_ACTIONS, V as POLICY_CAPABILITIES, W as POLICY_RULE_TYPES, X as X402PaymentRequirements, Y as X402Authorization, Z as X402Resource, _ as AccountDepositAddressResponse, a as IntentSubmitError, b as AccountsResponse, c as ACCOUNT_AGGREGATION_SCOPES, d as ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, et as X402SignedReceipt, f as ACCOUNT_TRANSACTION_STATUSES, g as AccountDepositAddressParams, h as AccountBalanceResponse, i as FetchLike, j as INTENT_ACTION_TYPES, k as CrossChainSend, l as ACCOUNT_DEPOSIT_ADDRESS_SOURCES, m as ACTOR_AGGREGATION_SCOPES, n as CatenaClient, o as TimeoutError, p as ACCOUNT_TRANSACTION_TYPES, q as SendMethod, r as CatenaClientOptions, s as createCatenaClient, t as ApiError, u as ACCOUNT_TRANSACTION_METHODS, v as AccountTransactionsParams, w as CROSS_CHAIN_NEXT_STEPS, x as Agent, y as AccountTransactionsResponse, z as OnchainAssetInput } from "./client-B_Gi0aqH.mjs";
+export { ACCOUNT_AGGREGATION_SCOPES, ACCOUNT_DEPOSIT_ADDRESS_SOURCES, ACCOUNT_TRANSACTION_METHODS, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, ACCOUNT_TRANSACTION_STATUSES, ACCOUNT_TRANSACTION_TYPES, ACTOR_AGGREGATION_SCOPES, type AccountBalanceResponse, type AccountDepositAddressParams, type AccountDepositAddressResponse, type AccountTransactionsParams, type AccountTransactionsResponse, type AccountsResponse, type Agent, ApiError, type AppInfo, COUNTERPARTY_ACTIONS, COUNTERPARTY_RULE_MODES, CROSS_CHAIN_NEXT_STEPS, CROSS_CHAIN_STATES, type CatenaClient, CatenaClientOptions, type CounterpartiesParams, type CounterpartiesResponse, type Counterparty, type CrossChainSend, type ExtensibleString, FetchLike, INTENT_ACTION_TYPES, type IntentAction, type IntentResult, IntentSubmitError, InvalidKeyError, MOVEMENT_NEXT_STEPS, type Movement, type MppAction, type MppChallenge, type MppResource, type OnchainAssetInput, type OnchainNetworkInput, POLICY_CAPABILITIES, POLICY_OVERRIDE_CAPABILITIES, POLICY_RULE_ACTIONS, POLICY_RULE_TYPES, type Policy, SEND_METHODS, type SendMethod, TimeoutError, type WalletCounterpartyRail, type X402Authorization, type X402PaymentRequirements, type X402Resource, type X402SignedOffer, type X402SignedReceipt, createCatenaClient };

package/dist/client.mjs

@@ -0,0 +1,3 @@
+import { InvalidKeyError } from "./keypair.mjs";
+import { S as SEND_METHODS, _ as MOVEMENT_NEXT_STEPS, a as ACCOUNT_AGGREGATION_SCOPES, b as POLICY_RULE_ACTIONS, c as ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, d as ACTOR_AGGREGATION_SCOPES, f as COUNTERPARTY_ACTIONS, g as INTENT_ACTION_TYPES, h as CROSS_CHAIN_STATES, i as createCatenaClient, l as ACCOUNT_TRANSACTION_STATUSES, m as CROSS_CHAIN_NEXT_STEPS, n as IntentSubmitError, o as ACCOUNT_DEPOSIT_ADDRESS_SOURCES, p as COUNTERPARTY_RULE_MODES, r as TimeoutError, s as ACCOUNT_TRANSACTION_METHODS, t as ApiError, u as ACCOUNT_TRANSACTION_TYPES, v as POLICY_CAPABILITIES, x as POLICY_RULE_TYPES, y as POLICY_OVERRIDE_CAPABILITIES } from "./client-BSYVYJGm.mjs";
+export { ACCOUNT_AGGREGATION_SCOPES, ACCOUNT_DEPOSIT_ADDRESS_SOURCES, ACCOUNT_TRANSACTION_METHODS, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, ACCOUNT_TRANSACTION_STATUSES, ACCOUNT_TRANSACTION_TYPES, ACTOR_AGGREGATION_SCOPES, ApiError, COUNTERPARTY_ACTIONS, COUNTERPARTY_RULE_MODES, CROSS_CHAIN_NEXT_STEPS, CROSS_CHAIN_STATES, INTENT_ACTION_TYPES, IntentSubmitError, InvalidKeyError, MOVEMENT_NEXT_STEPS, POLICY_CAPABILITIES, POLICY_OVERRIDE_CAPABILITIES, POLICY_RULE_ACTIONS, POLICY_RULE_TYPES, SEND_METHODS, TimeoutError, createCatenaClient };

package/dist/keypair-BjMJtI3-.d.mts

@@ -0,0 +1,35 @@
+//#region src/keypair.d.ts
+interface P256Keypair {
+  algorithm: "p256";
+  privateKeyHex: string;
+  publicKeyHex: string;
+}
+/**
+ * The supplied value is not a usable P-256 key.
+ */
+declare class InvalidKeyError extends Error {
+  constructor(message: string);
+}
+/**
+ * Generate a fresh agent credential. Feed `privateKeyHex` to
+ * `createCatenaClient`; the public half (or its thumbprint) is what gets
+ * registered with Catena when the agent is linked. The SDK never persists
+ * keys — storage is the caller's responsibility.
+ */
+declare function generateP256Keypair(): P256Keypair;
+/**
+ * Derive the full keypair from the private scalar alone, so a corrupt key
+ * throws at construction instead of surfacing as bank-side invalid_signature
+ * 401s — and a mismatched pair cannot exist at all.
+ */
+declare function p256KeypairFromPrivateKeyHex(privateKeyHex: string): P256Keypair;
+declare function p256PointFromCompressedHex(publicKeyHex: string): Buffer | null;
+/**
+ * RFC 7638 JWK thumbprint of a P-256 public key — the stable id the API
+ * knows a linked credential by. Throws {@link InvalidKeyError} when the
+ * input is not a valid P-256 point.
+ */
+declare function computeP256PublicKeyThumbprint(publicKeyHex: string): string;
+declare function p256PublicKeyThumbprintFromPoint(point: Buffer): string;
+//#endregion
+export { p256KeypairFromPrivateKeyHex as a, generateP256Keypair as i, P256Keypair as n, p256PointFromCompressedHex as o, computeP256PublicKeyThumbprint as r, p256PublicKeyThumbprintFromPoint as s, InvalidKeyError as t };

package/dist/keypair.d.mts

@@ -0,0 +1,2 @@
+import { a as p256KeypairFromPrivateKeyHex, i as generateP256Keypair, n as P256Keypair, o as p256PointFromCompressedHex, r as computeP256PublicKeyThumbprint, s as p256PublicKeyThumbprintFromPoint, t as InvalidKeyError } from "./keypair-BjMJtI3-.mjs";
+export { InvalidKeyError, P256Keypair, computeP256PublicKeyThumbprint, generateP256Keypair, p256KeypairFromPrivateKeyHex, p256PointFromCompressedHex, p256PublicKeyThumbprintFromPoint };

package/dist/keypair.mjs

@@ -0,0 +1,50 @@
+import { ECDH, createECDH, createHash } from "node:crypto";
+//#region src/keypair.ts
+var InvalidKeyError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidKeyError";
+	}
+};
+function generateP256Keypair() {
+	const ecdh = createECDH("prime256v1");
+	ecdh.generateKeys();
+	return p256KeypairFromPrivateKeyHex(ecdh.getPrivateKey().toString("hex").padStart(64, "0"));
+}
+const PRIVATE_KEY_HEX = /^[0-9a-f]{64}$/i;
+function p256KeypairFromPrivateKeyHex(privateKeyHex) {
+	if (!PRIVATE_KEY_HEX.test(privateKeyHex)) throw new InvalidKeyError("P-256 private key must be 64 hex characters");
+	const normalized = privateKeyHex.toLowerCase();
+	const ecdh = createECDH("prime256v1");
+	try {
+		ecdh.setPrivateKey(Buffer.from(normalized, "hex"));
+	} catch {
+		throw new InvalidKeyError("value is not a valid P-256 private key (scalar out of range)");
+	}
+	return {
+		algorithm: "p256",
+		privateKeyHex: normalized,
+		publicKeyHex: ecdh.getPublicKey("hex", "compressed")
+	};
+}
+function p256PointFromCompressedHex(publicKeyHex) {
+	try {
+		const uncompressed = ECDH.convertKey(publicKeyHex, "prime256v1", "hex", "hex", "uncompressed");
+		const point = Buffer.isBuffer(uncompressed) ? uncompressed : Buffer.from(uncompressed, "hex");
+		return point.length === 65 ? point : null;
+	} catch {
+		return null;
+	}
+}
+function computeP256PublicKeyThumbprint(publicKeyHex) {
+	const point = p256PointFromCompressedHex(publicKeyHex);
+	if (point === null) throw new InvalidKeyError("value is not a valid P-256 public key");
+	return p256PublicKeyThumbprintFromPoint(point);
+}
+function p256PublicKeyThumbprintFromPoint(point) {
+	const x = point.subarray(1, 33).toString("base64url");
+	const y = point.subarray(33, 65).toString("base64url");
+	return createHash("sha256").update(`{"crv":"P-256","kty":"EC","x":"${x}","y":"${y}"}`, "utf8").digest("base64url");
+}
+//#endregion
+export { InvalidKeyError, computeP256PublicKeyThumbprint, generateP256Keypair, p256KeypairFromPrivateKeyHex, p256PointFromCompressedHex, p256PublicKeyThumbprintFromPoint };

package/dist/movements.d.mts

@@ -0,0 +1,139 @@
+//#region src/movements.d.ts
+/**
+ * Independent review of a movement approval, before anything is stamped.
+ *
+ * A movement is authorized by one signature over a batch of pre-hashed
+ * digests. A digest cannot be read, so a signing policy cannot constrain what
+ * it commits to: the only content control is the signer rebuilding every
+ * digest from the fields it is said to cover and refusing when they disagree.
+ * The console does this before it prompts for a passkey. An agent holds the
+ * same authority with a different credential, so it does the same thing here
+ * rather than stamping a body it has not checked.
+ *
+ * The check is local: no network, no server answer to trust. It proves that the
+ * request would sign exactly the digests the approval lists, that each of them
+ * is the payload shown for it, that every payload acts on the approval's own
+ * wallet and on the network it is labelled with, and that a delegation names
+ * the one contract a wallet here is allowed to hand itself to.
+ *
+ * It also refuses any payload that would move the network's own token, which
+ * is the one amount every kind states in a field rather than inside call data.
+ * On a chain whose gas token is the asset being moved, that value is a payment
+ * nothing else in the approval describes.
+ *
+ * Given the caller's own amount it also proves the approval pays it, for the
+ * approvals where that can be known: a transfer authorization states its
+ * amount in a field the digest covers, so an approval built only from those is
+ * bound to the sum they deliver.
+ *
+ * What it does not prove is what a payload's call data does. A raw transaction
+ * and a batch execution carry their recipient and amount as encoded call data,
+ * which is reproduced but not decoded, and a payment can be built entirely
+ * from those -- so an approval carrying one is not bound to any amount at all.
+ * For those kinds the guarantee is that the bytes signed are the bytes shown,
+ * not that the bytes shown are a payment to anyone in particular. Binding them
+ * needs that call data decoded, which would mean recognising every contract
+ * and call shape a payment can use and refusing any built from one this client
+ * does not know yet; that is not attempted here.
+ *
+ * Requires the optional `viem` peer dependency; importing this module without
+ * viem installed fails with a module-not-found error naming it.
+ */
+/**
+ * One thing the approval would sign, with every field its digest commits to.
+ */
+export interface MovementInstructionReview {
+  /**
+   * What kind of signable material this is.
+   */
+  kind: string;
+  /**
+   * The network it acts on.
+   */
+  network: string;
+  /**
+   * The wallet that must sign it.
+   */
+  signerAddress: string;
+  /**
+   * The digest the approval carries for it.
+   */
+  digest: string;
+  /**
+   * The fields the digest commits to.
+   */
+  payload: Record<string, unknown>;
+}
+/**
+ * The approval as prepared, as it arrives on a `submit_stamp` next action.
+ */
+export interface PreparedMovement {
+  /**
+   * The wallet every instruction must name.
+   */
+  signerAddress: string;
+  /**
+   * Every digest the approval would sign, in order.
+   */
+  digests: readonly string[];
+  /**
+   * What each of those digests commits to.
+   */
+  instructions: readonly MovementInstructionReview[];
+  /**
+   * The provider request body that would be stamped.
+   */
+  body: string;
+}
+/**
+ * What the caller asked for, to check the approval against. Only the amount
+ * today: a counterparty rail is named by id rather than by address, and this
+ * client cannot resolve one locally, so the recipient stays unbound.
+ */
+export interface RequestedPayment {
+  /**
+   * The amount as the caller wrote it, in USDC.
+   */
+  amount: string;
+}
+export type MovementReviewVerdict = {
+  ok: true;
+} | {
+  ok: false;
+  reason: string;
+};
+/**
+ * Recompute an instruction's digest from the fields it says it covers, or
+ * `null` when the payload does not parse as its kind. A `null` is a refusal,
+ * never a pass.
+ */
+export declare function rebuildInstructionDigest(instruction: Pick<MovementInstructionReview, "kind" | "payload">): string | null;
+/**
+ * Whether a prepared movement may be stamped: every digest rebuilt from the
+ * fields it says it covers, every instruction naming the same signer and the
+ * network it actually signs on, no payload spending from another wallet, no
+ * delegation handing the wallet to an unrecognised contract, the approval
+ * listing exactly those digests, and the request body pinned to them and to
+ * that signer.
+ *
+ * Refuse on anything but `ok`. A reason describes what disagreed, and a
+ * disagreement means the body would sign something other than what it
+ * describes.
+ *
+ * No instruction may move the network's own token, which is the one amount
+ * every kind states in a field rather than inside call data.
+ *
+ * Pass `requested` to also check the approval against what the caller asked
+ * for. That binds only when every payload able to move value states its amount
+ * in a named field; an approval carrying one whose amount lives in call data
+ * is left unbound, because a sum over the rest would bind nothing.
+ *
+ * This checks that a payload is the one shown for its digest. It does not
+ * decode call data, so for kinds that carry their recipient and amount as
+ * encoded call data rather than as named fields, a passing verdict means the
+ * bytes signed are the bytes shown, not that they pay a particular party for a
+ * particular amount. The recipient is never bound: a counterparty rail is
+ * named by id, and this client cannot resolve one to an address on its own.
+ */
+export declare function verifyPreparedMovement(prepared: PreparedMovement, requested?: RequestedPayment): MovementReviewVerdict;
+//#endregion

package/dist/movements.mjs

@@ -0,0 +1,334 @@
+import * as v from "valibot";
+import { getAddress, hashAuthorization, hashTypedData, keccak256, serializeTransaction } from "viem/utils";
+//#region src/movements.ts
+const addressSchema = v.pipe(v.string(), v.transform(getAddress));
+const digitsSchema = v.pipe(v.string(), v.regex(/^\d+$/));
+const hexBytesSchema = v.custom((value) => typeof value === "string" && /^0x([0-9a-fA-F]{2})*$/.test(value), "expected hex bytes");
+const bytes32Schema = v.custom((value) => typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value), "expected a 32-byte value");
+const USDC_EIP3009_NETWORKS = ["base", "base-sepolia"];
+const USDC_EIP3009_DOMAINS = {
+	base: {
+		name: "USD Coin",
+		version: "2",
+		chainId: 8453,
+		verifyingContract: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+	},
+	"base-sepolia": {
+		name: "USDC",
+		version: "2",
+		chainId: 84532,
+		verifyingContract: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+	}
+};
+const GAS_DELEGATE_DOMAIN = {
+	name: "TKGasDelegate",
+	version: "1.1"
+};
+const GAS_DELEGATE_ADDRESS = "0x955d84139e7621bc571b117d8eb5d28a4a222c6f";
+const NETWORK_CHAIN_IDS = {
+	...Object.fromEntries(Object.entries(USDC_EIP3009_DOMAINS).map(([network, domain]) => [network, domain.chainId])),
+	arc: 5042
+};
+const rawTransactionSchema = v.looseObject({ transaction: v.object({
+	chainId: v.pipe(v.number(), v.integer(), v.minValue(1)),
+	nonce: v.pipe(v.number(), v.integer(), v.minValue(0)),
+	to: addressSchema,
+	value: digitsSchema,
+	data: hexBytesSchema,
+	gas: digitsSchema,
+	maxFeePerGasWei: digitsSchema,
+	maxPriorityFeePerGasWei: digitsSchema
+}) });
+const transferAuthorizationSchema = v.looseObject({
+	network: v.picklist(USDC_EIP3009_NETWORKS),
+	authorization: v.object({
+		from: addressSchema,
+		to: addressSchema,
+		value: digitsSchema,
+		validAfter: v.union([v.number(), digitsSchema]),
+		validBefore: v.union([v.number(), digitsSchema]),
+		nonce: bytes32Schema
+	})
+});
+const delegationSchema = v.looseObject({ authorization: v.object({
+	address: addressSchema,
+	chainId: v.pipe(v.number(), v.integer(), v.minValue(1)),
+	nonce: v.pipe(v.number(), v.integer(), v.minValue(0))
+}) });
+const batchExecutionSchema = v.looseObject({ batch: v.object({
+	from: addressSchema,
+	chainId: v.pipe(v.number(), v.integer(), v.minValue(1)),
+	nonce: digitsSchema,
+	deadline: v.pipe(v.number(), v.integer(), v.minValue(1)),
+	calls: v.pipe(v.array(v.object({
+		to: addressSchema,
+		value: digitsSchema,
+		data: hexBytesSchema
+	})), v.minLength(1))
+}) });
+const preparedBodySchema = v.looseObject({
+	type: v.literal("ACTIVITY_TYPE_SIGN_RAW_PAYLOADS"),
+	parameters: v.looseObject({
+		signWith: addressSchema,
+		payloads: v.pipe(v.array(bytes32Schema), v.minLength(1)),
+		encoding: v.literal("PAYLOAD_ENCODING_HEXADECIMAL"),
+		hashFunction: v.literal("HASH_FUNCTION_NO_OP")
+	})
+});
+function usdcBaseUnits(amount) {
+	const match = /^(\d+)(?:\.(\d{1,6}))?$/.exec(amount.trim());
+	if (match === null) return null;
+	const [, whole = "0", fraction = ""] = match;
+	return BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, "0"));
+}
+function instructionFacts(instruction) {
+	try {
+		switch (instruction.kind) {
+			case "evm_raw_transaction": {
+				const { transaction } = v.parse(rawTransactionSchema, instruction.payload);
+				return {
+					digest: keccak256(serializeTransaction({
+						type: "eip1559",
+						chainId: transaction.chainId,
+						nonce: transaction.nonce,
+						to: transaction.to,
+						value: BigInt(transaction.value),
+						data: transaction.data,
+						gas: BigInt(transaction.gas),
+						maxFeePerGas: BigInt(transaction.maxFeePerGasWei),
+						maxPriorityFeePerGas: BigInt(transaction.maxPriorityFeePerGasWei),
+						accessList: []
+					})),
+					chainId: transaction.chainId,
+					movesNative: BigInt(transaction.value) !== 0n
+				};
+			}
+			case "eip3009_transfer_authorization": {
+				const { network, authorization } = v.parse(transferAuthorizationSchema, instruction.payload);
+				return {
+					digest: hashTypedData({
+						domain: USDC_EIP3009_DOMAINS[network],
+						types: { TransferWithAuthorization: [
+							{
+								name: "from",
+								type: "address"
+							},
+							{
+								name: "to",
+								type: "address"
+							},
+							{
+								name: "value",
+								type: "uint256"
+							},
+							{
+								name: "validAfter",
+								type: "uint256"
+							},
+							{
+								name: "validBefore",
+								type: "uint256"
+							},
+							{
+								name: "nonce",
+								type: "bytes32"
+							}
+						] },
+						primaryType: "TransferWithAuthorization",
+						message: {
+							from: authorization.from,
+							to: authorization.to,
+							value: BigInt(authorization.value),
+							validAfter: BigInt(authorization.validAfter),
+							validBefore: BigInt(authorization.validBefore),
+							nonce: authorization.nonce
+						}
+					}),
+					chainId: USDC_EIP3009_DOMAINS[network].chainId,
+					from: authorization.from
+				};
+			}
+			case "eip7702_delegation": {
+				const { authorization } = v.parse(delegationSchema, instruction.payload);
+				return {
+					digest: hashAuthorization({
+						address: authorization.address,
+						chainId: authorization.chainId,
+						nonce: authorization.nonce
+					}),
+					chainId: authorization.chainId,
+					delegate: authorization.address
+				};
+			}
+			case "eip712_execution": {
+				const { batch } = v.parse(batchExecutionSchema, instruction.payload);
+				return {
+					digest: hashTypedData({
+						domain: {
+							...GAS_DELEGATE_DOMAIN,
+							chainId: batch.chainId,
+							verifyingContract: batch.from
+						},
+						types: {
+							BatchExecution: [
+								{
+									name: "nonce",
+									type: "uint128"
+								},
+								{
+									name: "deadline",
+									type: "uint32"
+								},
+								{
+									name: "calls",
+									type: "Call[]"
+								}
+							],
+							Call: [
+								{
+									name: "to",
+									type: "address"
+								},
+								{
+									name: "value",
+									type: "uint256"
+								},
+								{
+									name: "data",
+									type: "bytes"
+								}
+							]
+						},
+						primaryType: "BatchExecution",
+						message: {
+							nonce: BigInt(batch.nonce),
+							deadline: batch.deadline,
+							calls: batch.calls.map((call) => ({
+								to: call.to,
+								value: BigInt(call.value),
+								data: call.data
+							}))
+						}
+					}),
+					from: batch.from,
+					chainId: batch.chainId,
+					movesNative: batch.calls.some((call) => BigInt(call.value) !== 0n)
+				};
+			}
+		}
+	} catch {
+		return null;
+	}
+	return null;
+}
+function rebuildInstructionDigest(instruction) {
+	return instructionFacts(instruction)?.digest ?? null;
+}
+function sameList(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function verifyPreparedMovement(prepared, requested) {
+	if (prepared.instructions.length === 0) return {
+		ok: false,
+		reason: "The approval carries nothing to sign."
+	};
+	const signer = prepared.signerAddress.toLowerCase();
+	for (const instruction of prepared.instructions) {
+		const facts = instructionFacts(instruction);
+		if (facts === null || facts.digest.toLowerCase() !== instruction.digest.toLowerCase()) return {
+			ok: false,
+			reason: "An instruction does not match what it says it signs."
+		};
+		if (instruction.signerAddress.toLowerCase() !== signer) return {
+			ok: false,
+			reason: "An instruction names a different wallet than the approval."
+		};
+		const named = NETWORK_CHAIN_IDS[instruction.network];
+		if (named === void 0) return {
+			ok: false,
+			reason: `An instruction names a network this client cannot place: ${instruction.network}. If the payment looks right, this client may be out of date.`
+		};
+		if (facts.chainId !== named) return {
+			ok: false,
+			reason: "An instruction names a different network than it signs on."
+		};
+		if (facts.delegate !== void 0 && facts.delegate.toLowerCase() !== GAS_DELEGATE_ADDRESS) return {
+			ok: false,
+			reason: "An instruction would hand the wallet over to an unrecognised contract."
+		};
+		if (facts.from !== void 0 && facts.from.toLowerCase() !== signer) return {
+			ok: false,
+			reason: "An instruction would spend from a different wallet."
+		};
+		if (facts.movesNative === true) return {
+			ok: false,
+			reason: "An instruction would move the network's own token."
+		};
+	}
+	const rebuiltDigests = prepared.instructions.map((instruction) => instruction.digest.toLowerCase());
+	if (new Set(rebuiltDigests).size !== rebuiltDigests.length) return {
+		ok: false,
+		reason: "The approval lists the same digest more than once."
+	};
+	const spentNonces = new Set();
+	for (const instruction of prepared.instructions) {
+		if (instruction.kind !== "eip3009_transfer_authorization") continue;
+		const parsed = v.safeParse(transferAuthorizationSchema, instruction.payload);
+		if (!parsed.success) continue;
+		const { network, authorization } = parsed.output;
+		const spent = `${network}:${authorization.from.toLowerCase()}:${authorization.nonce.toLowerCase()}`;
+		if (spentNonces.has(spent)) return {
+			ok: false,
+			reason: "The approval spends one authorization nonce twice."
+		};
+		spentNonces.add(spent);
+	}
+	if (!sameList(prepared.digests.map((digest) => digest.toLowerCase()), rebuiltDigests)) return {
+		ok: false,
+		reason: "The approval lists different digests than its instructions."
+	};
+	let body;
+	try {
+		body = v.parse(preparedBodySchema, JSON.parse(prepared.body));
+	} catch {
+		return {
+			ok: false,
+			reason: "The prepared request is not in the shape expected."
+		};
+	}
+	if (!sameList(body.parameters.payloads.map((payload) => payload.toLowerCase()), rebuiltDigests)) return {
+		ok: false,
+		reason: "The prepared request would sign different digests."
+	};
+	if (body.parameters.signWith.toLowerCase() !== signer) return {
+		ok: false,
+		reason: "The prepared request names a different wallet than the approval."
+	};
+	return bindsRequestedAmount(prepared, signer, requested);
+}
+function bindsRequestedAmount(prepared, signer, requested) {
+	if (requested === void 0) return { ok: true };
+	const wanted = usdcBaseUnits(requested.amount);
+	if (wanted === null) return {
+		ok: false,
+		reason: "The requested amount is not an amount this client can check."
+	};
+	let delivered = 0n;
+	for (const instruction of prepared.instructions) {
+		if (instruction.kind === "evm_raw_transaction" || instruction.kind === "eip712_execution") return { ok: true };
+		if (instruction.kind !== "eip3009_transfer_authorization") continue;
+		const parsed = v.safeParse(transferAuthorizationSchema, instruction.payload);
+		if (!parsed.success) return {
+			ok: false,
+			reason: "An instruction does not match what it says it signs."
+		};
+		if (parsed.output.authorization.to.toLowerCase() !== signer) delivered += BigInt(parsed.output.authorization.value);
+	}
+	if (delivered === wanted) return { ok: true };
+	return {
+		ok: false,
+		reason: "This approval does not pay the amount that was requested."
+	};
+}
+//#endregion
+export { rebuildInstructionDigest, verifyPreparedMovement };