accounts 0.18.3 → 0.18.5

package/src/core/Provider.localnet.test.ts

@@ -11,6 +11,9 @@ import {
 } from 'viem'
 import {
   getBalance,
+  getBlockNumber,
+  getLogs,
+  getTransactionReceipt,
   sendCalls,
   sendTransactionSync,
   signMessage,
@@ -2192,6 +2195,66 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
   })
 
   describe('wallet_revokeAccessKey', () => {
+    test('error: rejects an authorization for a different access key', async () => {
+      const provider = Provider.create({ adapter: adapter(), chains: [chain] })
+      await connect(provider)
+
+      const connected = (await provider.request({ method: 'eth_accounts' }))[0]!
+      const first = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+      const second = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+
+      await expect(
+        provider.request({
+          method: 'wallet_revokeAccessKey',
+          params: [
+            {
+              address: connected,
+              accessKeyAddress: first.keyAuthorization.address!,
+              keyAuthorization: second.keyAuthorization,
+            },
+          ],
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `[RpcResponse.InvalidParamsError: \`keyAuthorization\` must authorize \`accessKeyAddress\`.]`,
+      )
+    })
+
+    test('behavior: atomically authorizes and revokes an unpublished access key', async () => {
+      const provider = Provider.create({ adapter: adapter(), chains: [chain] })
+      await connect(provider)
+
+      const connected = (await provider.request({ method: 'eth_accounts' }))[0]!
+      await fund(connected)
+
+      const { keyAuthorization } = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+
+      await provider.request({
+        method: 'wallet_revokeAccessKey',
+        params: [
+          {
+            address: connected,
+            accessKeyAddress: keyAuthorization.address!,
+            keyAuthorization,
+          },
+        ],
+      })
+
+      const metadata = await Actions.accessKey.getMetadata(getClient(), {
+        account: connected,
+        accessKey: keyAuthorization.address!,
+      })
+      expect(metadata.isRevoked).toMatchInlineSnapshot(`true`)
+    })
+
     test('default: revokes a granted access key on-chain', async () => {
       const provider = Provider.create({ adapter: adapter(), chains: [chain] })
       await connect(provider)
@@ -3232,6 +3295,57 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
       expect((result.tx as { feePayerSignature?: unknown }).feePayerSignature).toBeDefined()
     })
 
+    test('behavior: feePayer URL sponsors wallet_revokeAccessKey', async () => {
+      const provider = Provider.create({ adapter: adapter(), chains: [chain] })
+      const connected = await connect(provider)
+      await fund(connected)
+      const { keyAuthorization } = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+      await provider.request({
+        method: 'eth_sendTransactionSync',
+        params: [{ calls: [transferCall] }],
+      })
+
+      const rpc = getClient()
+      const blockNumber = await getBlockNumber(rpc)
+
+      await provider.request({
+        method: 'wallet_revokeAccessKey',
+        params: [
+          {
+            accessKeyAddress: keyAuthorization.address!,
+            address: connected,
+            feePayer: server.url,
+          },
+        ],
+      })
+
+      const logs = await getLogs(rpc, {
+        address: Addresses.accountKeychain,
+        fromBlock: blockNumber,
+        toBlock: 'latest',
+      })
+      const event = Actions.accessKey.revoke.extractEvent(logs)
+      const receipt = await getTransactionReceipt(rpc, { hash: event.transactionHash })
+      const metadata = await Actions.accessKey.getMetadata(rpc, {
+        account: connected,
+        accessKey: keyAuthorization.address!,
+      })
+      expect({
+        feePayer: receipt.feePayer,
+        isRevoked: metadata.isRevoked,
+        status: receipt.status,
+      }).toMatchInlineSnapshot(`
+        {
+          "feePayer": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+          "isRevoked": true,
+          "status": "success",
+        }
+      `)
+    })
+
     test('behavior: feePayer: true uses default from Provider.create', async () => {
       const provider = Provider.create({
         adapter: adapter({ feePayer: server.url }),

package/src/core/Provider.ts

@@ -558,28 +558,29 @@ export function create(options: create.Options = {}): create.ReturnType {
     })
   }
 
-  async function revokeAccessKey(parameters: {
-    address: Address.Address
-    accessKeyAddress: Address.Address
-  }) {
+  async function revokeAccessKey(parameters: Adapter.revokeAccessKey.Parameters) {
     const selected = await getAdapterAccount({ address: parameters.address })
+    const feePayer = parameters.feePayer
     const client = getWalletClient({
       account: selected.account,
+      feePayer: feePayer === true ? undefined : feePayer,
       transport: selected.transport,
     })
     if (selected.account.type === 'json-rpc') {
       await client.request({
         method: 'wallet_revokeAccessKey' as never,
-        params: [parameters] as never,
+        params: [z.encode(Rpc.wallet_revokeAccessKey.parameters, parameters)] as never,
       })
     } else {
       try {
-        await Actions.accessKey.revokeSync(getClient(), {
+        await Actions.accessKey.revokeSync(client, {
           account: selected.account as TempoAccount.Account,
           accessKey: parameters.accessKeyAddress,
+          ...(feePayer ? { feePayer: true as never } : {}),
+          ...(parameters.keyAuthorization ? { keyAuthorization: parameters.keyAuthorization } : {}),
         })
       } catch (error) {
-        if (!AccessKey.isUnavailableError(error)) throw error
+        if (typeof feePayer === 'string' || !AccessKey.isUnavailableError(error)) throw error
       }
     }
     store.accessKeys.remove({
@@ -677,6 +678,13 @@ export function create(options: create.Options = {}): create.ReturnType {
     parameters: Adapter.revokeAccessKey.Parameters,
     request: Pick<Rpc.wallet_revokeAccessKey.Encoded, 'method' | 'params'>,
   ) {
+    if (
+      parameters.keyAuthorization &&
+      !AddressUtil.isEqual(parameters.keyAuthorization.address, parameters.accessKeyAddress)
+    )
+      throw new RpcResponse.InvalidParamsError({
+        message: '`keyAuthorization` must authorize `accessKeyAddress`.',
+      })
     if (actions.revokeAccessKey) return await actions.revokeAccessKey(parameters, request)
     if (instance.getAccount) return await revokeAccessKey(parameters)
     unsupported('revokeAccessKey')
@@ -713,6 +721,12 @@ export function create(options: create.Options = {}): create.ReturnType {
     return url
   }
 
+  function resolveRevocationFeePayer(
+    feePayer: string | boolean | undefined,
+  ): Adapter.revokeAccessKey.Parameters['feePayer'] {
+    return resolveFeePayer(feePayer) ?? (feePayer === true ? true : undefined)
+  }
+
   function stripAuthorizeAccessKey(
     parameters: create.AuthorizeAccessKeyParameters,
   ): Adapter.authorizeAccessKey.Parameters {
@@ -1608,7 +1622,10 @@ export function create(options: create.Options = {}): create.ReturnType {
                   case 'wallet_revokeAccessKey': {
                     assertConnected()
                     const [decoded] = request._decoded.params
-                    await revokeAccessKeyAction({ ...decoded }, request)
+                    await revokeAccessKeyAction(
+                      { ...decoded, feePayer: resolveRevocationFeePayer(decoded.feePayer) },
+                      request,
+                    )
                     return
                   }
 

package/src/core/Schema.test-d.ts

@@ -1,4 +1,5 @@
 import type { RpcSchema } from 'ox'
+import type { KeyAuthorization } from 'ox/tempo'
 import type { Hex } from 'viem'
 import { describe, expectTypeOf, test } from 'vp/test'
 
@@ -214,6 +215,15 @@ describe('Encoded', () => {
               amount?: string | undefined
               chainId?: Hex | undefined
               displayName?: string | undefined
+              intent?:
+                | 'applePay'
+                | 'credits'
+                | 'crypto'
+                | 'faucet'
+                | 'mach'
+                | 'referralCode'
+                | 'x'
+                | undefined
               token?: Hex | string | undefined
             },
           ]
@@ -300,6 +310,19 @@ describe('Request', () => {
     expectTypeOf<SwitchChain['params']>().toEqualTypeOf<readonly [{ chainId: number }]>()
   })
 
+  test('wallet_revokeAccessKey supports app-provided fee sponsorship', () => {
+    expectTypeOf<Rpc.wallet_revokeAccessKey.Decoded['params']>().toEqualTypeOf<
+      readonly [
+        {
+          accessKeyAddress: Hex
+          address: Hex
+          feePayer?: boolean | string | undefined
+          keyAuthorization?: KeyAuthorization.Signed | undefined
+        },
+      ]
+    >()
+  })
+
   test('eth_accounts has no params', () => {
     type EthAccounts = Extract<Schema.Request, { method: 'eth_accounts' }>
     expectTypeOf<EthAccounts>().not.toHaveProperty('params')

package/src/core/adapters/postMessage/mount.test.ts

@@ -69,6 +69,57 @@ describe('auto', () => {
   })
 })
 
+describe('iframe', () => {
+  test('behavior: matches the iframe color scheme to the wallet theme', () => {
+    const elements: Record<string, unknown>[] = []
+    vi.stubGlobal('document', {
+      body: {
+        appendChild() {},
+      },
+      createElement(tag: string) {
+        const element = {
+          appendChild() {},
+          contentWindow: null,
+          dataset: {},
+          innerHTML: '',
+          remove() {},
+          setAttribute() {},
+          style: {},
+          tag,
+        }
+        elements.push(element)
+        return element
+      },
+    })
+    vi.stubGlobal(
+      'MutationObserver',
+      class {
+        disconnect() {}
+        observe() {}
+      },
+    )
+
+    Mount.iframe()({
+      host: 'https://wallet.tempo.xyz/post-message?scheme=dark',
+      onDismiss() {},
+      onInvalidate() {},
+    })
+
+    expect(elements.find((element) => element.tag === 'iframe')?.style).toMatchInlineSnapshot(`
+      {
+        "backgroundColor": "transparent",
+        "border": "0",
+        "colorScheme": "dark",
+        "height": "100%",
+        "left": "0",
+        "position": "fixed",
+        "top": "0",
+        "width": "100%",
+      }
+    `)
+  })
+})
+
 describe('postMessage', () => {
   test('behavior: derives trusted hosts from the wallet host', () => {
     const factory = Object.assign(

package/src/core/adapters/postMessage/mount.ts

@@ -96,7 +96,9 @@ export function iframe(): Factory {
   return Object.assign(
     (parameters: Factory.Parameters): Mount => {
       const { host, onDismiss, onInvalidate } = parameters
-      const origin = new URL(host).origin
+      const url = new URL(host)
+      const origin = url.origin
+      const scheme = url.searchParams.get('scheme')
 
       const root = document.createElement('dialog')
       // Distinct marker from the bespoke `Dialog.iframe` (`data-tempo-wallet`)
@@ -132,7 +134,7 @@ export function iframe(): Factory {
       Object.assign(frame.style, {
         backgroundColor: 'transparent',
         border: '0',
-        colorScheme: 'light dark',
+        colorScheme: scheme === 'light' || scheme === 'dark' ? scheme : 'light dark',
         height: '100%',
         left: '0',
         position: 'fixed',

package/src/core/adapters/privy.test.ts

@@ -1,5 +1,5 @@
 import { Address as core_Address, Hex, Secp256k1, Signature } from 'ox'
-import { decodeFunctionData } from 'viem'
+import { BaseError, decodeFunctionData } from 'viem'
 import type { Address } from 'viem/accounts'
 import { Abis } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
@@ -323,6 +323,140 @@ describe('privy', () => {
     expect(store.getState().accessKeys).toMatchInlineSnapshot(`[]`)
   })
 
+  test('behavior: revokeAccessKey forwards a fee payer URL', async () => {
+    const { adapter, client, store } = setup()
+    store.setState({ accounts: [{ address }], activeAccount: 0 })
+
+    await adapter.actions.revokeAccessKey!(
+      { accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' },
+      {
+        method: 'wallet_revokeAccessKey',
+        params: [{ accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' }],
+      },
+    )
+
+    expect({
+      clientOptions: client.clientOptions,
+      transactions: client.transactions,
+    }).toMatchInlineSnapshot(`
+      {
+        "clientOptions": [
+          {
+            "feePayer": "https://example.com/fee-payer",
+          },
+        ],
+        "transactions": [
+          {
+            "account": {
+              "address": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+              "sign": [Function],
+              "signTransaction": [Function],
+              "source": "privy",
+              "type": "local",
+            },
+            "data": "0x5ae7ab320000000000000000000000002b5ad5c4795c026514f8317c7a215e218dccd6cf",
+            "feePayer": true,
+            "to": "0xaAAAaaAA00000000000000000000000000000000",
+          },
+        ],
+      }
+    `)
+  })
+
+  test('error: revokeAccessKey preserves local state on external fee payer errors', async () => {
+    const transactionError = new BaseError('revoke failed', {
+      cause: Object.assign(new Error('execution reverted'), {
+        data: { errorName: 'KeyAlreadyRevoked' },
+      }),
+    })
+    const { adapter, store } = setup({ transactionError })
+    store.setState({
+      accounts: [{ address }],
+      activeAccount: 0,
+      accessKeys: [
+        {
+          access: address,
+          address: other,
+          chainId: 1,
+          keyType: 'secp256k1',
+        } as never,
+      ],
+    })
+
+    await expect(
+      adapter.actions.revokeAccessKey!(
+        { accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' },
+        {
+          method: 'wallet_revokeAccessKey',
+          params: [{ accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' }],
+        },
+      ),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      [ContractFunctionExecutionError: revoke failed
+
+      Contract Call:
+        address:   0xaAAAaaAA00000000000000000000000000000000
+        function:  revokeKey(address keyId)
+        args:               (0x2b5ad5c4795c026514f8317c7a215e218dccd6cf)
+        sender:    0x7e5f4552091a69125d5dfcb7b8c2659029395bdf
+
+      Docs: https://viem.sh/docs/contract/writeContract
+      Details: execution reverted
+      Version: viem@2.56.0]
+    `)
+
+    expect(store.getState().accessKeys).toMatchInlineSnapshot(`
+      [
+        {
+          "access": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+          "address": "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
+          "chainId": 1,
+          "keyType": "secp256k1",
+        },
+      ]
+    `)
+  })
+
+  test('behavior: revokeAccessKey forwards default fee sponsorship', async () => {
+    const { adapter, client, store } = setup()
+    store.setState({ accounts: [{ address }], activeAccount: 0 })
+
+    await adapter.actions.revokeAccessKey!(
+      { accessKeyAddress: other, address, feePayer: true },
+      {
+        method: 'wallet_revokeAccessKey',
+        params: [{ accessKeyAddress: other, address, feePayer: true }],
+      },
+    )
+
+    expect({
+      clientOptions: client.clientOptions,
+      transactions: client.transactions,
+    }).toMatchInlineSnapshot(`
+      {
+        "clientOptions": [
+          {
+            "feePayer": undefined,
+          },
+        ],
+        "transactions": [
+          {
+            "account": {
+              "address": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+              "sign": [Function],
+              "signTransaction": [Function],
+              "source": "privy",
+              "type": "local",
+            },
+            "data": "0x5ae7ab320000000000000000000000002b5ad5c4795c026514f8317c7a215e218dccd6cf",
+            "feePayer": true,
+            "to": "0xaAAAaaAA00000000000000000000000000000000",
+          },
+        ],
+      }
+    `)
+  })
+
   test('behavior: signing silently restores wallet accounts via the Privy SDK', async () => {
     const { adapter, client, store } = setup()
     store.setState({ accounts: [{ address }], activeAccount: 0 })
@@ -642,13 +776,17 @@ function setup(options: setup.Options = {}) {
     getAccount: (() => {
       throw new Error('not implemented')
     }) as never,
-    getClient: (() => ({
-      chain: { id: 1 },
-      sendTransaction: async (parameters: unknown) => {
-        client.transactions.push(parameters)
-        return Hex.padLeft('0x1', 32)
-      },
-    })) as never,
+    getClient: ((clientOptions: unknown) => {
+      client.clientOptions.push(clientOptions)
+      return {
+        chain: { id: 1 },
+        sendTransaction: async (parameters: unknown) => {
+          client.transactions.push(parameters)
+          if (options.transactionError) throw options.transactionError
+          return Hex.padLeft('0x1', 32)
+        },
+      }
+    }) as never,
     storage,
     store,
   })
@@ -675,6 +813,8 @@ declare namespace setup {
     restoreError?: unknown
     token?: string | null | undefined
     signError?: unknown
+    /** Make the mock wallet client transaction fail. */
+    transactionError?: unknown
     /** Override the value returned by the embedded provider's `secp256k1_sign`. */
     signResult?: unknown
     /** Force the test wallet to sign with this private key (for wrong-signer tests). */
@@ -683,6 +823,7 @@ declare namespace setup {
 }
 
 type MockClient = privy.Client & {
+  clientOptions: unknown[]
   createCalls: number
   initCalls: number
   loadCalls: number
@@ -699,6 +840,7 @@ type MockClient = privy.Client & {
 
 function createClient(options: setup.Options = {}) {
   const client: MockClient = {
+    clientOptions: [] as unknown[],
     createCalls: 0,
     initCalls: 0,
     loadCalls: 0,

package/src/core/adapters/privy.ts

@@ -570,13 +570,21 @@ export function privy<const client extends privy.Client>(
         },
         async revokeAccessKey(parameters) {
           const account = await getSigningAccount(parameters.address)
+          const { feePayer } = parameters
           try {
-            await Actions.accessKey.revoke(getClient(), {
-              account: account as never,
-              accessKey: parameters.accessKeyAddress,
-            })
+            await Actions.accessKey.revoke(
+              getClient({ feePayer: feePayer === true ? undefined : feePayer }),
+              {
+                account: account as never,
+                accessKey: parameters.accessKeyAddress,
+                ...(feePayer ? { feePayer: true } : {}),
+                ...(parameters.keyAuthorization
+                  ? { keyAuthorization: parameters.keyAuthorization }
+                  : {}),
+              },
+            )
           } catch (error) {
-            if (!AccessKey.isUnavailableError(error)) throw error
+            if (typeof feePayer === 'string' || !AccessKey.isUnavailableError(error)) throw error
           }
           store.accessKeys.remove({
             accessKey: parameters.accessKeyAddress,

package/src/core/zod/request.test.ts

@@ -69,6 +69,32 @@ describe('validate', () => {
     `)
   })
 
+  test('behavior: preserves access-key revocation sponsorship', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'wallet_revokeAccessKey',
+      params: [
+        {
+          accessKeyAddress: '0x2222222222222222222222222222222222222222',
+          address: '0x1111111111111111111111111111111111111111',
+          feePayer: 'https://app.example.com/fee-payer',
+        },
+      ],
+    })
+
+    expect(result._decoded).toMatchInlineSnapshot(`
+      {
+        "method": "wallet_revokeAccessKey",
+        "params": [
+          {
+            "accessKeyAddress": "0x2222222222222222222222222222222222222222",
+            "address": "0x1111111111111111111111111111111111111111",
+            "feePayer": "https://app.example.com/fee-payer",
+          },
+        ],
+      }
+    `)
+  })
+
   test('default: validates wallet_switchEthereumChain with hex chainId', () => {
     const result = RpcRequest.validate(Schema.Request, {
       method: 'wallet_switchEthereumChain',
@@ -115,13 +141,14 @@ describe('validate', () => {
     `)
   })
 
-  test('default: validates wallet_deposit with amount and token symbol', () => {
+  test('default: validates wallet_deposit with MACH intent and pre-filled fields', () => {
     const result = RpcRequest.validate(Schema.Request, {
       method: 'wallet_deposit',
       params: [
         {
           amount: '50',
           displayName: 'DoorDash',
+          intent: 'mach',
           token: 'USDC',
         },
       ],
@@ -133,6 +160,7 @@ describe('validate', () => {
           {
             "amount": "50",
             "displayName": "DoorDash",
+            "intent": "mach",
             "token": "USDC",
           },
         ],

package/src/core/zod/rpc.ts

@@ -540,11 +540,21 @@ export namespace wallet_authorizeAccessKey_strict {
 }
 
 export namespace wallet_revokeAccessKey {
+  /** Parameters for revoking an access key. */
+  export const parameters = z.object({
+    /** Root account address. */
+    address: u.address(),
+    /** Address of the access key to revoke. */
+    accessKeyAddress: u.address(),
+    /** App-provided fee sponsorship for the revocation transaction. */
+    feePayer: z.optional(z.union([z.boolean(), z.string()])),
+    /** Signed authorization for an access key that has not been published on-chain. */
+    keyAuthorization: z.optional(keyAuthorization),
+  })
+
   export const schema = Schema.defineItem({
     method: z.literal('wallet_revokeAccessKey'),
-    params: z.readonly(
-      z.tuple([z.object({ address: u.address(), accessKeyAddress: u.address() })]),
-    ),
+    params: z.readonly(z.tuple([parameters])),
     returns: undefined,
   })
   export type Encoded = Schema.Encoded<typeof schema>
@@ -1021,6 +1031,7 @@ export namespace wallet_deposit {
                 z.literal('credits'),
                 z.literal('crypto'),
                 z.literal('faucet'),
+                z.literal('mach'),
                 z.literal('referralCode'),
                 z.literal('x'),
               ]),