@metalntwx/metal-pay 0.3.2 → 0.3.3

package/dist/clearing-client.js

@@ -81,6 +81,15 @@ export function createClearingClient(config) {
     const chain = createPublicClient({ transport: rpcTransport(config.rpcUrl) });
     let tail = Promise.resolve();
     let broken = false;
+    // The contract writes its clearing unit once, so one successful read serves every payment.
+    let unitRead;
+    function unit() {
+        unitRead ??= chain.readContract({ address: config.settlement, abi: clearingAbi, functionName: "unit" }).catch((error) => {
+            unitRead = undefined;
+            throw error;
+        });
+        return unitRead;
+    }
     async function save(state) {
         try {
             await config.store.save(state);
@@ -173,15 +182,11 @@ export function createClearingClient(config) {
             if (BigInt(context.epoch) !== epoch)
                 return betweenEpochs(cause);
             opened = true;
-            const [{ amount }, unit] = await Promise.all([
+            const [{ amount }, units] = await Promise.all([
                 request(`/spendable/${config.signer.publicKey}`),
-                chain.readContract({
-                    address: config.settlement,
-                    abi: clearingAbi,
-                    functionName: "unit",
-                }),
+                unit(),
             ]);
-            covered = BigInt(amount) >= clearingUnits(BigInt(invoice.amount), unit);
+            covered = BigInt(amount) >= clearingUnits(BigInt(invoice.amount), units);
         }
         catch (error) {
             if (!opened && unavailable(error))
@@ -271,7 +276,7 @@ export function createClearingClient(config) {
                 context.asset.toLowerCase() !== config.asset.toLowerCase())
                 throw new Error("unsupported clearing service deployment");
             const epoch = BigInt(context.epoch);
-            const [registered, onchain, fault, admitted, block, unit] = await onChain(Promise.all([
+            const [registered, onchain, fault, admitted, block, units] = await onChain(Promise.all([
                 chain.readContract({
                     address: config.settlement,
                     abi: clearingAbi,
@@ -294,11 +299,7 @@ export function createClearingClient(config) {
                     functionName: "admittedCount",
                 }),
                 chain.getBlock(),
-                chain.readContract({
-                    address: config.settlement,
-                    abi: clearingAbi,
-                    functionName: "unit",
-                }),
+                unit(),
             ]));
             if (fault)
                 throw faulted();
@@ -320,7 +321,7 @@ export function createClearingClient(config) {
                 entries.push(entry);
             }
             // The invoice is in token base units; the vector counts clearing units.
-            entry.cumulative = (BigInt(entry.cumulative) + clearingUnits(amount, unit)).toString();
+            entry.cumulative = (BigInt(entry.cumulative) + clearingUnits(amount, units)).toString();
             entry.count = (BigInt(entry.count) + 1n).toString();
             // The service takes at most this many recipients in one payment's vector.
             if (entries.length > MAX_ENTRIES)

package/dist/mandates/account.js

@@ -13,6 +13,7 @@ export const ACCOUNT_BATCH_MODE = "0x0100000000000000000000000000000000000000000
 export function metalAccountCode(implementation) {
     return concat(["0x363d3d373d3d3d363d73", implementation, "0x5af43d82803e903d91602b57fd5bf3"]).toLowerCase();
 }
+const EARLIER_FACTORY = "such as an earlier one";
 /** The factory is a caller-selected trust anchor, never inferred from payer-controlled data. */
 export async function assertMetalAccount(client, account, factory, blockNumber) {
     const at = blockNumber === undefined ? {} : { blockNumber };
@@ -21,8 +22,11 @@ export async function assertMetalAccount(client, account, factory, blockNumber)
     const when = blockNumber === undefined ? "" : ` at block ${blockNumber}`;
     if (code === undefined || code === "0x")
         throw new Error(`${account} has no code${when}: no account is deployed there`);
-    if (code.toLowerCase() !== metalAccountCode(implementation))
-        throw new Error(`${account} is not a MetalAccount clone of the trusted factory ${factory}`);
+    if (code.toLowerCase() === metalAccountCode(implementation))
+        return;
+    if (/^0x363d3d373d3d3d363d73[0-9a-f]{40}5af43d82803e903d91602b57fd5bf3$/.test(code.toLowerCase()))
+        throw new Error(`${account} was made by another factory than ${factory}, ${EARLIER_FACTORY}`);
+    throw new Error(`${account} is not a MetalAccount clone of the trusted factory ${factory}`);
 }
 /** The account's own execution, with a quorum of keys. */
 const EXECUTION_GAS = 500000n;
@@ -72,7 +76,10 @@ export async function authorizeMandateCall(client, factory, call, validUntil, si
     const account = first.to;
     if (calls.some((c) => !isAddressEqual(c.to, account)))
         throw new Error("every call in one batch goes to the same account");
-    await assertMetalAccount(client, account, factory);
+    await assertMetalAccount(client, account, factory).catch((error) => {
+        // Only the owner can act on it, so only the owner's path says what to do.
+        throw error.message.endsWith(EARLIER_FACTORY) ? new Error(`${error.message}: create a new account with this version`, { cause: error }) : error;
+    });
     // A fresh nonce lane per call: two administration calls in flight, or one
     // beside the owner's own operations on lane 0, never claim one nonce. A
     // quorum's lane keeps the key's top bit clear; set, it is a lane for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metalntwx/metal-pay",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Agent payments on Metal for the official x402 packages: native Bajillion clearing, on-chain exact payments, durable payer wallets, seller integration, and mandates, which let an agent pay from its owner's account within limits Metal enforces.",
   "license": "MIT",
   "repository": {
@@ -48,7 +48,7 @@
     "@x402/evm": "2.28.0",
     "@x402/fetch": "2.28.0",
     "@x402/hono": "2.28.0",
-    "hono": "4.13.7",
+    "hono": "4.13.13",
     "tsx": "^4.23.0",
     "typescript": "~6.0.2",
     "viem": "^2",

package/src/clearing-client.test.ts

@@ -29,11 +29,12 @@ const OTHER = "http://seller.test/chunk/2";
 /** The Clearing contract's epoch count, the service's epoch 1 admitted, its fault, none, the chain's id, and whether the contract is there, unless set otherwise. */
 const chain = { admitted: 1n, fault: 0, id: 1337, deployed: true };
 const head = { root: ZERO32, operations: 0n, floor: 0n };
+let unitReads = 0;
 const views: Record<string, () => unknown> = {
   registered: () => true,
   fault: () => chain.fault,
   admittedCount: () => chain.admitted,
-  unit: () => UNIT,
+  unit: () => (unitReads++, UNIT),
   operatorKey: () => operator.publicKey,
   contextOf: () => ({
     anchor: ANCHOR,
@@ -689,6 +690,29 @@ describe("clearing refusals", () => {
   });
 });
 
+describe("chain reads", () => {
+  it("reads the contract's clearing unit once, since the contract writes it once", async () => {
+    const before = unitReads;
+    const { client, posted } = wallet();
+    await client.pay(invoiceFor(CHUNK), CHUNK);
+    await client.pay(invoiceFor(OTHER), OTHER);
+    expect(posted).toHaveLength(2);
+    expect(unitReads - before).toBe(1);
+  });
+
+  it("reads the unit again after a read that failed", async () => {
+    const { client, posted } = wallet();
+    chain.deployed = false;
+    try {
+      await expect(client.pay(invoiceFor(CHUNK), CHUNK)).rejects.toThrow();
+    } finally {
+      chain.deployed = true;
+    }
+    await client.pay(invoiceFor(OTHER), OTHER);
+    expect(posted).toHaveLength(1);
+  });
+});
+
 describe("registerClearingClient", () => {
   it("refuses a request for another URL while a payment is held, naming the held one, then pays the held one once", async () => {
     const { client: clearing, posted } = wallet({ payments: [lost] });

package/src/clearing-client.ts

@@ -201,6 +201,15 @@ export function createClearingClient(config: ClearingClientConfig) {
   const chain = createPublicClient({ transport: rpcTransport(config.rpcUrl) });
   let tail: Promise<unknown> = Promise.resolve();
   let broken = false;
+  // The contract writes its clearing unit once, so one successful read serves every payment.
+  let unitRead: Promise<bigint> | undefined;
+  function unit() {
+    unitRead ??= chain.readContract({ address: config.settlement, abi: clearingAbi, functionName: "unit" }).catch((error: unknown) => {
+      unitRead = undefined;
+      throw error;
+    });
+    return unitRead;
+  }
   async function save(state: ClearingClientState) {
     try {
       await config.store.save(state);
@@ -294,15 +303,11 @@ export function createClearingClient(config: ClearingClientConfig) {
       if (fault) return faulted(cause);
       if (BigInt(context.epoch) !== epoch) return betweenEpochs(cause);
       opened = true;
-      const [{ amount }, unit] = await Promise.all([
+      const [{ amount }, units] = await Promise.all([
         request<{ amount: string }>(`/spendable/${config.signer.publicKey}`),
-        chain.readContract({
-          address: config.settlement,
-          abi: clearingAbi,
-          functionName: "unit",
-        }),
+        unit(),
       ]);
-      covered = BigInt(amount) >= clearingUnits(BigInt(invoice.amount), unit);
+      covered = BigInt(amount) >= clearingUnits(BigInt(invoice.amount), units);
     } catch (error) {
       if (!opened && unavailable(error)) return closed(cause);
       return new Error(
@@ -428,7 +433,7 @@ export function createClearingClient(config: ClearingClientConfig) {
       )
         throw new Error("unsupported clearing service deployment");
       const epoch = BigInt(context.epoch);
-      const [registered, onchain, fault, admitted, block, unit] =
+      const [registered, onchain, fault, admitted, block, units] =
         await onChain(Promise.all([
           chain.readContract({
             address: config.settlement,
@@ -452,11 +457,7 @@ export function createClearingClient(config: ClearingClientConfig) {
             functionName: "admittedCount",
           }),
           chain.getBlock(),
-          chain.readContract({
-            address: config.settlement,
-            abi: clearingAbi,
-            functionName: "unit",
-          }),
+          unit(),
         ]));
       if (fault) throw faulted();
       // The contract has not registered the service's epoch yet, or has
@@ -484,7 +485,7 @@ export function createClearingClient(config: ClearingClientConfig) {
       }
       // The invoice is in token base units; the vector counts clearing units.
       entry.cumulative = (
-        BigInt(entry.cumulative) + clearingUnits(amount, unit)
+        BigInt(entry.cumulative) + clearingUnits(amount, units)
       ).toString();
       entry.count = (BigInt(entry.count) + 1n).toString();
       // The service takes at most this many recipients in one payment's vector.

package/src/mandates/account.ts

@@ -17,6 +17,8 @@ export function metalAccountCode(implementation: Address): Hex {
   return concat(["0x363d3d373d3d3d363d73", implementation, "0x5af43d82803e903d91602b57fd5bf3"]).toLowerCase() as Hex;
 }
 
+const EARLIER_FACTORY = "such as an earlier one";
+
 /** The factory is a caller-selected trust anchor, never inferred from payer-controlled data. */
 export async function assertMetalAccount(client: PublicClient, account: Address, factory: Address, blockNumber?: bigint): Promise<void> {
   const at = blockNumber === undefined ? {} : { blockNumber };
@@ -24,7 +26,10 @@ export async function assertMetalAccount(client: PublicClient, account: Address,
   const code = await client.getCode({ address: account, ...at });
   const when = blockNumber === undefined ? "" : ` at block ${blockNumber}`;
   if (code === undefined || code === "0x") throw new Error(`${account} has no code${when}: no account is deployed there`);
-  if (code.toLowerCase() !== metalAccountCode(implementation)) throw new Error(`${account} is not a MetalAccount clone of the trusted factory ${factory}`);
+  if (code.toLowerCase() === metalAccountCode(implementation)) return;
+  if (/^0x363d3d373d3d3d363d73[0-9a-f]{40}5af43d82803e903d91602b57fd5bf3$/.test(code.toLowerCase()))
+    throw new Error(`${account} was made by another factory than ${factory}, ${EARLIER_FACTORY}`);
+  throw new Error(`${account} is not a MetalAccount clone of the trusted factory ${factory}`);
 }
 
 /** The account's own execution, with a quorum of keys. */
@@ -72,7 +77,10 @@ export async function authorizeMandateCall(client: PublicClient, factory: Addres
   if (first === undefined) throw new Error("no call to authorize");
   const account = first.to;
   if (calls.some((c) => !isAddressEqual(c.to, account))) throw new Error("every call in one batch goes to the same account");
-  await assertMetalAccount(client, account, factory);
+  await assertMetalAccount(client, account, factory).catch((error: Error) => {
+    // Only the owner can act on it, so only the owner's path says what to do.
+    throw error.message.endsWith(EARLIER_FACTORY) ? new Error(`${error.message}: create a new account with this version`, { cause: error }) : error;
+  });
   // A fresh nonce lane per call: two administration calls in flight, or one
   // beside the owner's own operations on lane 0, never claim one nonce. A
   // quorum's lane keeps the key's top bit clear; set, it is a lane for