accounts 0.18.4 → 0.19.0

package/src/core/AccessKey.permissions.test.ts

@@ -0,0 +1,73 @@
+import { Json } from 'ox'
+import { KeyAuthorization } from 'ox/tempo'
+import { describe, expect, test } from 'vp/test'
+
+import { accounts, privateKeys } from '../../test/config.js'
+import * as Storage from './Storage.js'
+import * as Store from './Store.js'
+
+const account = accounts[0]!.address
+const address = accounts[1]!.address
+
+describe('stored permission semantics', () => {
+  test.each([undefined, [], [{ token: address, limit: 100n }]])(
+    'preserves limits through authorization updates and persistence: %#',
+    async (limits) => {
+      const storage = Storage.memory()
+      const store = Store.create({ chainId: 1, storage })
+      await Store.waitForHydration(store)
+      const scopes = limits === undefined ? undefined : limits.length === 0 ? [] : [{ address }]
+      const authorization = KeyAuthorization.from(
+        { address, chainId: 1n, type: 'secp256k1', limits, scopes },
+        { signature: `0x${'00'.repeat(65)}` },
+      )
+      const key = store.accessKeys.add({ account, authorization, privateKey: privateKeys[1] })
+      expect(key.permissionSemantics).toMatchInlineSnapshot(`1`)
+      expect(key.limits).toEqual(limits)
+      expect(key.scopes).toEqual(scopes)
+
+      // Replace legacy metadata with a complete authorization, then clear the pending signature.
+      store.setState({
+        accessKeys: [{ ...key, permissionSemantics: undefined, limits: [], scopes: [] }],
+      })
+      store.accessKeys.updateAuthorization({
+        account,
+        accessKey: address,
+        chainId: 1,
+        authorization,
+      })
+      store.setState((state) => ({
+        accessKeys: state.accessKeys.map((key) => ({ ...key, keyAuthorization: undefined })),
+      }))
+      const restored = Store.create({ chainId: 1, storage })
+      await Store.waitForHydration(restored)
+      expect(Json.stringify(restored.getState().accessKeys)).toBe(
+        Json.stringify([{ ...key, keyAuthorization: undefined }]),
+      )
+    },
+  )
+
+  test('does not mark legacy records during hydration', async () => {
+    const storage = Storage.memory()
+    const store = Store.create({ chainId: 1, storage })
+    await Store.waitForHydration(store)
+    store.setState({
+      accessKeys: [
+        {
+          address,
+          access: account,
+          chainId: 1,
+          keyType: 'secp256k1',
+          limits: [],
+          scopes: [],
+          privateKey: privateKeys[1],
+        },
+      ],
+    })
+    const restored = Store.create({ chainId: 1, storage })
+    await Store.waitForHydration(restored)
+    expect(restored.getState().accessKeys[0]?.permissionSemantics).toMatchInlineSnapshot(
+      `undefined`,
+    )
+  })
+})

package/src/core/AccessKey.test.ts

@@ -23,7 +23,7 @@ function createKeyAuthorization(
   options: {
     chainId?: bigint | undefined
     expiry?: number | undefined
-    keyType?: KeyAuthorization.KeyAuthorization['type'] | undefined
+    keyType?: AccessKey.prepareAuthorization.Options['keyType'] | undefined
     limits?: { token: `0x${string}`; limit: bigint; period?: number | undefined }[] | undefined
     scopes?: KeyAuthorization.Scope[] | undefined
   } = {},
@@ -506,18 +506,19 @@ describe('authorize', () => {
     `)
     expect(store.getState().accessKeys.map(({ keyAuthorization: _, ...accessKey }) => accessKey))
       .toMatchInlineSnapshot(`
-      [
-        {
-          "access": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-          "address": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
-          "chainId": 1,
-          "expiry": 123,
-          "keyType": "secp256k1",
-          "limits": undefined,
-          "scopes": undefined,
-        },
-      ]
-    `)
+        [
+          {
+            "access": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            "address": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
+            "chainId": 1,
+            "expiry": 123,
+            "keyType": "secp256k1",
+            "limits": undefined,
+            "permissionSemantics": 1,
+            "scopes": undefined,
+          },
+        ]
+      `)
   })
 
   test('behavior: provisions a handle-backed record via the keystore', async () => {
@@ -590,19 +591,20 @@ describe('authorize', () => {
 
     expect(store.getState().accessKeys.map(({ keyAuthorization: _, ...accessKey }) => accessKey))
       .toMatchInlineSnapshot(`
-      [
-        {
-          "access": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-          "address": "${accessKey.address}",
-          "chainId": 1,
-          "expiry": 123,
-          "keyType": "secp256k1",
-          "limits": undefined,
-          "privateKey": "${privateKeys[1]}",
-          "scopes": undefined,
-        },
-      ]
-    `)
+        [
+          {
+            "access": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            "address": "${accessKey.address}",
+            "chainId": 1,
+            "expiry": 123,
+            "keyType": "secp256k1",
+            "limits": undefined,
+            "permissionSemantics": 1,
+            "privateKey": "${privateKeys[1]}",
+            "scopes": undefined,
+          },
+        ]
+      `)
   })
 })
 
@@ -1078,7 +1080,7 @@ describe('getStatus', () => {
 
       Docs: https://viem.sh/docs/contract/readContract
       Details: RPC unavailable.
-      Version: viem@2.56.0]
+      Version: viem@2.56.9]
     `)
   })
 

package/src/core/AccessKey.ts

@@ -44,6 +44,8 @@ export type AccessKey = {
   keyType: 'secp256k1' | 'p256' | 'webAuthn' | 'webCrypto'
   /** TIP-20 spending limits for the access key. */
   limits?: { token: Address.Address; limit: bigint; period?: number | undefined }[] | undefined
+  /** Version of stored permission semantics: omitted fields are unrestricted, empty arrays deny all. Absent on legacy records. */
+  permissionSemantics?: 1 | undefined
   /** Call scopes restricting which contracts/selectors this key can call. */
   scopes?:
     | {
@@ -345,7 +347,9 @@ export declare namespace prepareAuthorization {
     /** Keystore-created key material reference. */
     key?: { handle: Keystore.Handle; publicKey: Hex.Hex } | undefined
     /** Unsigned key authorization to sign with the root account. */
-    keyAuthorization: KeyAuthorization.KeyAuthorization<false>
+    keyAuthorization: KeyAuthorization.KeyAuthorization<false> & {
+      type: NonNullable<Options['keyType']>
+    }
     /** Exported private key backing an external access key. */
     privateKey?: Hex.Hex | undefined
   }
@@ -558,6 +562,7 @@ export function add(options: add.Options): add.ReturnType {
     expiry: authorization.expiry ?? undefined,
     keyAuthorization: authorization,
     keyType: authorization.type,
+    permissionSemantics: 1 as const,
     limits: authorization.limits as AccessKey['limits'],
     scopes: authorization.scopes as AccessKey['scopes'],
   }
@@ -624,6 +629,7 @@ function updateAuthorization(options: updateAuthorization.Options): void {
     patch: {
       expiry: authorization.expiry ?? undefined,
       keyAuthorization: authorization,
+      permissionSemantics: 1,
       limits: authorization.limits as AccessKey['limits'],
       scopes: authorization.scopes as AccessKey['scopes'],
     },

package/src/core/Adapter.ts

@@ -443,6 +443,10 @@ export declare namespace revokeAccessKey {
     address: Address
     /** Address of the access key to revoke. */
     accessKeyAddress: Address
+    /** App-provided fee sponsorship for the revocation transaction. */
+    feePayer?: boolean | string | undefined
+    /** Signed authorization for an access key that has not been published on-chain. */
+    keyAuthorization?: KeyAuthorization.Signed | undefined
   }
 }
 

package/src/core/Client.test.ts

@@ -1,6 +1,10 @@
+import { Secp256k1 } from 'ox'
+import { TxEnvelopeTempo } from 'ox/tempo'
 import { custom, http } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { Transaction } from 'viem/tempo'
 import { tempo, tempoModerato } from 'viem/tempo/chains'
-import { describe, expect, test } from 'vp/test'
+import { afterEach, describe, expect, test, vi } from 'vp/test'
 
 import { secp256k1 } from '../../test/adapters.js'
 import * as Client from './Client.js'
@@ -252,6 +256,37 @@ describe('providerTransport', () => {
 })
 
 describe('feePayerTransport', () => {
+  afterEach(() => vi.unstubAllGlobals())
+
+  const sender = privateKeyToAccount(
+    '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+  )
+  const feePayerPrivateKey = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+
+  async function sponsoredTransaction(data: `0x${string}`) {
+    const requested = await sender.signTransaction(
+      {
+        calls: [{ data, to: '0x20c0000000000000000000000000000000000000' }],
+        chainId: tempo.id,
+        feePayer: true,
+        gas: 100_000n,
+        maxFeePerGas: 2n,
+        maxPriorityFeePerGas: 1n,
+        nonce: 1,
+      } as never,
+      { serializer: Transaction.serialize },
+    )
+    const envelope = TxEnvelopeTempo.deserialize(requested as TxEnvelopeTempo.Serialized)
+    const feePayerSignature = Secp256k1.sign({
+      payload: TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender: envelope.from! }),
+      privateKey: feePayerPrivateKey,
+    })
+    return {
+      requested,
+      signed: TxEnvelopeTempo.serialize(envelope, { feePayerSignature }),
+    }
+  }
+
   test('behavior: passes through unrelated methods to the base transport', async () => {
     const store = setup()
     const baseRequests: { method: string; params?: unknown }[] = []
@@ -337,4 +372,121 @@ describe('feePayerTransport', () => {
       ]
     `)
   })
+
+  test('behavior: accepts a fee payer signature for the requested transaction', async () => {
+    const store = setup()
+    const { requested, signed } = await sponsoredTransaction('0x1234')
+    vi.stubGlobal('fetch', async (_input: string | URL, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as { id: number }
+      return Response.json({ id: body.id, jsonrpc: '2.0', result: signed })
+    })
+    const baseRequests: { method: string; params?: unknown }[] = []
+    const hash = `0x${'11'.repeat(32)}` as `0x${string}`
+    const client = Client.fromChainId(tempo.id, {
+      chains: [tempo],
+      feePayer: 'https://relay.example.com',
+      store,
+      transports: {
+        [tempo.id]: custom({
+          async request({ method, params }) {
+            baseRequests.push({ method, params })
+            return hash
+          },
+        }),
+      },
+    })
+
+    const result = await client.request({
+      method: 'eth_sendRawTransaction',
+      params: [requested],
+    })
+
+    expect(result).toMatchInlineSnapshot(
+      `"0x1111111111111111111111111111111111111111111111111111111111111111"`,
+    )
+    expect(baseRequests.map((request) => request.method)).toMatchInlineSnapshot(`
+      [
+        "eth_sendRawTransaction",
+      ]
+    `)
+    const sent = baseRequests[0]?.params as readonly unknown[] | undefined
+    expect(sent?.[0]).toBe(signed)
+  })
+
+  test('error: rejects a fee payer signature for a different transaction', async () => {
+    const store = setup()
+    const { requested } = await sponsoredTransaction('0x1234')
+    const { signed } = await sponsoredTransaction('0x5678')
+    vi.stubGlobal('fetch', async (_input: string | URL, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as { id: number }
+      return Response.json({ id: body.id, jsonrpc: '2.0', result: signed })
+    })
+    const baseRequests: unknown[] = []
+    const client = Client.fromChainId(tempo.id, {
+      chains: [tempo],
+      feePayer: 'https://relay.example.com',
+      store,
+      transports: {
+        [tempo.id]: custom({
+          async request(request) {
+            baseRequests.push(request)
+            return null
+          },
+        }),
+      },
+    })
+
+    await expect(
+      client.request({ method: 'eth_sendRawTransaction', params: [requested] }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Error: Fee payer changed the requested transaction intent.]`,
+    )
+    expect(baseRequests).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('error: rejects a filled transaction that changes the requested call', async () => {
+    const store = setup()
+    const request = {
+      calls: [{ data: '0x1234', to: '0x20c0000000000000000000000000000000000000', value: '0x' }],
+      chainId: '0x1079',
+      feePayer: true,
+      from: sender.address,
+      type: '0x76',
+    } as const
+    vi.stubGlobal('fetch', async (_input: string | URL, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as { id: number }
+      return Response.json({
+        id: body.id,
+        jsonrpc: '2.0',
+        result: {
+          raw: '0x',
+          tx: {
+            ...request,
+            calls: [{ ...request.calls[0], data: '0x5678' }],
+          },
+        },
+      })
+    })
+    const baseRequests: unknown[] = []
+    const client = Client.fromChainId(tempo.id, {
+      chains: [tempo],
+      feePayer: 'https://relay.example.com',
+      store,
+      transports: {
+        [tempo.id]: custom({
+          async request(request) {
+            baseRequests.push(request)
+            return null
+          },
+        }),
+      },
+    })
+
+    await expect(
+      client.request({ method: 'eth_fillTransaction' as never, params: [request] as never }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Error: Fee payer changed the requested transaction intent.]`,
+    )
+    expect(baseRequests).toMatchInlineSnapshot(`[]`)
+  })
 })

package/src/core/Client.ts

@@ -1,4 +1,5 @@
 import { type Provider as ox_Provider } from 'ox'
+import { TxEnvelopeTempo } from 'ox/tempo'
 import {
   type Chain,
   createClient,
@@ -163,11 +164,14 @@ function feePayerTransport(
             typeof request === 'object' &&
             'feePayer' in request &&
             (request.feePayer === true || typeof request.feePayer === 'string')
-          )
-            return sponsor.request({
+          ) {
+            const response = await sponsor.request({
               method,
               params: [{ ...request, feePayer: true }],
             })
+            assertFilledTransactionIntent(request, response)
+            return response
+          }
         }
 
         if (method === 'eth_sendRawTransaction' || method === 'eth_sendRawTransactionSync') {
@@ -182,6 +186,7 @@ function feePayerTransport(
                 method: 'eth_signRawTransaction',
                 params: [serialized],
               })
+              assertSignedTransactionIntent(serialized, signed)
               return await baseTransport.request({ method, params: [signed] })
             }
           }
@@ -192,3 +197,69 @@ function feePayerTransport(
     } as ReturnType<Transport>
   }
 }
+
+function assertFilledTransactionIntent(request: Record<string, unknown>, response: unknown) {
+  if (!isObject(response) || !isObject(response.tx))
+    throw new Error('Fee payer returned an invalid filled transaction.')
+
+  const transaction = response.tx
+  if (
+    (request.from !== undefined && !sameAddress(request.from, transaction.from)) ||
+    (request.chainId !== undefined && !sameQuantity(request.chainId, transaction.chainId)) ||
+    (request.calls !== undefined && !sameCalls(request.calls, transaction.calls))
+  )
+    throw new Error('Fee payer changed the requested transaction intent.')
+}
+
+function assertSignedTransactionIntent(serialized: string, signed: unknown) {
+  if (typeof signed !== 'string' || (!signed.startsWith('0x76') && !signed.startsWith('0x78')))
+    throw new Error('Fee payer returned an invalid signed transaction.')
+
+  const requested = TxEnvelopeTempo.deserialize(serialized as TxEnvelopeTempo.Serialized)
+  const transaction = TxEnvelopeTempo.deserialize(signed as TxEnvelopeTempo.Serialized)
+  if (
+    !transaction.feePayerSignature ||
+    !sameAddress(requested.from, transaction.from) ||
+    TxEnvelopeTempo.getSignPayload(requested) !== TxEnvelopeTempo.getSignPayload(transaction)
+  )
+    throw new Error('Fee payer changed the requested transaction intent.')
+}
+
+function sameCalls(a: unknown, b: unknown) {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false
+  return a.every((call, index) => {
+    const other = b[index]
+    return (
+      isObject(call) &&
+      isObject(other) &&
+      sameAddress(call.to, other.to) &&
+      sameQuantity(call.value, other.value) &&
+      sameHex(call.data, other.data)
+    )
+  })
+}
+
+function sameAddress(a: unknown, b: unknown) {
+  if (a === undefined && b === undefined) return true
+  return typeof a === 'string' && typeof b === 'string' && a.toLowerCase() === b.toLowerCase()
+}
+
+function sameHex(a: unknown, b: unknown) {
+  const normalize = (value: unknown) =>
+    typeof value === 'string' ? value.toLowerCase() : value === undefined ? '0x' : undefined
+  return normalize(a) === normalize(b)
+}
+
+function sameQuantity(a: unknown, b: unknown) {
+  const normalize = (value: unknown) => {
+    if (value === undefined || value === null || value === '0x') return 0n
+    if (typeof value === 'bigint') return value
+    if (typeof value === 'number' || typeof value === 'string') return BigInt(value)
+    return undefined
+  }
+  return normalize(a) === normalize(b)
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}