accounts 0.18.4 → 0.18.5

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',

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>

package/src/react/Remote.test.ts

@@ -0,0 +1,153 @@
+import { vi } from 'vitest'
+import { afterEach, describe, expect, test } from 'vp/test'
+
+const hooks = vi.hoisted(() => ({ cleanups: [] as (() => void)[] }))
+
+vi.mock('react', () => ({
+  useCallback: (fn: unknown) => fn,
+  useEffect: (effect: () => void | (() => void)) => {
+    const cleanup = effect()
+    if (cleanup) hooks.cleanups.push(cleanup)
+  },
+  useMemo: (fn: () => unknown) => fn(),
+  useRef: (current: unknown) => ({ current }),
+  useState: (initial: unknown) => [initial, () => {}],
+}))
+
+import { useTheme } from './Remote.js'
+
+afterEach(() => {
+  hooks.cleanups.length = 0
+  vi.unstubAllGlobals()
+})
+
+describe('useTheme', () => {
+  test('behavior: applies URL theme values to the document', () => {
+    const root = createRoot()
+    stubBrowser(root, '?accent=%23b9a3ff&radius=medium&scheme=dark')
+
+    useTheme()
+
+    expect(readRoot(root)).toMatchInlineSnapshot(`
+      {
+        "attributes": {
+          "data-theme": "dark",
+          "data-theme-accent": "custom",
+          "data-theme-radius": "medium",
+        },
+        "colorScheme": "dark",
+        "properties": {
+          "--theme-accent": "#b9a3ff",
+        },
+      }
+    `)
+  })
+
+  test('behavior: replaces URL overrides with live theme updates', () => {
+    const root = createRoot()
+    stubBrowser(root, '?accent=purple&radius=full&scheme=dark')
+    let update: ((theme: { scheme?: string }) => void) | undefined
+    const remote = {
+      messenger: {
+        on(_topic: string, listener: typeof update) {
+          update = listener
+          return () => {}
+        },
+      },
+    }
+    useTheme(remote as never)
+
+    update?.({ scheme: 'light' })
+
+    expect(readRoot(root)).toMatchInlineSnapshot(`
+      {
+        "attributes": {
+          "data-theme": "light",
+        },
+        "colorScheme": "light",
+        "properties": {},
+      }
+    `)
+  })
+
+  test('behavior: restores the document theme when unmounted', () => {
+    const root = createRoot(
+      {
+        'data-theme': 'light',
+        'data-theme-accent': 'custom',
+        'data-theme-radius': 'small',
+      },
+      'light',
+      { '--theme-accent': '#ff007a' },
+    )
+    stubBrowser(root, '?accent=blue&radius=full&scheme=dark')
+    useTheme()
+
+    hooks.cleanups[0]?.()
+
+    expect(readRoot(root)).toMatchInlineSnapshot(`
+      {
+        "attributes": {
+          "data-theme": "light",
+          "data-theme-accent": "custom",
+          "data-theme-radius": "small",
+        },
+        "colorScheme": "light",
+        "properties": {
+          "--theme-accent": "#ff007a",
+        },
+      }
+    `)
+  })
+})
+
+// Helpers
+
+function stubBrowser(root: ReturnType<typeof createRoot>, search: string) {
+  vi.stubGlobal('document', { documentElement: root })
+  vi.stubGlobal('window', { location: { search } })
+}
+
+function createRoot(
+  initialAttributes: Record<string, string> = {},
+  colorScheme = '',
+  initialProperties: Record<string, string> = {},
+) {
+  const attributes = new Map(Object.entries(initialAttributes))
+  const properties = new Map(Object.entries(initialProperties))
+  return {
+    attributes,
+    getAttribute(name: string) {
+      return attributes.get(name) ?? null
+    },
+    removeAttribute(name: string) {
+      attributes.delete(name)
+    },
+    setAttribute(name: string, value: string) {
+      attributes.set(name, value)
+    },
+    style: {
+      colorScheme,
+      getPropertyValue(name: string) {
+        return properties.get(name) ?? ''
+      },
+      removeProperty(name: string) {
+        const value = properties.get(name) ?? ''
+        properties.delete(name)
+        return value
+      },
+      setProperty(name: string, value: string) {
+        properties.set(name, value)
+      },
+    },
+    properties,
+  }
+}
+
+function readRoot(root: ReturnType<typeof createRoot>) {
+  return {
+    attributes: Object.fromEntries(root.attributes),
+    colorScheme: root.style.colorScheme,
+    properties: Object.fromEntries(root.properties),
+  }
+}

package/src/react/Remote.ts

@@ -126,7 +126,10 @@ function applyTheme(theme: {
     root.setAttribute('data-theme-accent', getAccentName(accent))
     if (!isAccentPreset(accent)) root.style.setProperty('--theme-accent', accent)
   }
-  if (scheme) root.style.colorScheme = scheme
+  if (scheme) {
+    root.style.colorScheme = scheme
+    root.setAttribute('data-theme', scheme)
+  }
   if (radius) root.setAttribute('data-theme-radius', radius)
 }
 
@@ -137,11 +140,13 @@ function captureTheme(): ThemeSnapshot {
     accentValue: root.style.getPropertyValue('--theme-accent'),
     colorScheme: root.style.colorScheme,
     radius: root.getAttribute('data-theme-radius'),
+    scheme: root.getAttribute('data-theme'),
   }
 }
 
 function restoreTheme(snapshot: ThemeSnapshot) {
   const root = document.documentElement
+  restoreAttribute(root, 'data-theme', snapshot.scheme)
   restoreAttribute(root, 'data-theme-accent', snapshot.accentPreset)
   restoreAttribute(root, 'data-theme-radius', snapshot.radius)
   if (snapshot.accentValue) root.style.setProperty('--theme-accent', snapshot.accentValue)
@@ -175,6 +180,7 @@ type ThemeSnapshot = {
   accentValue: string
   colorScheme: string
   radius: string | null
+  scheme: string | null
 }
 
 export declare namespace useEnsureVisibility {

package/src/trusted-hosts.json

@@ -3,6 +3,7 @@
     "localhost",
     "*.localhost",
     "*.tempo.xyz",
+    "mercator.sh",
     "paradigm.xyz",
     "promptgolf.sh",
     "app.polyhedge.capital",