accounts 0.14.0 → 0.14.2

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

@@ -56,10 +56,11 @@ function connectRequest(
   options: {
     accessKey?: typeof accessKey | undefined
     expiry?: number | undefined
+    method?: 'login' | 'register' | undefined
     showDeposit?: z.output<typeof CliAuth.createRequest>['showDeposit'] | undefined
   } = {},
 ) {
-  const { accessKey: key = accessKey, expiry: expiry_ = expiry, showDeposit } = options
+  const { accessKey: key = accessKey, expiry: expiry_ = expiry, method, showDeposit } = options
 
   return {
     method: 'wallet_connect',
@@ -71,7 +72,8 @@ function connectRequest(
             keyType: key.keyType,
             publicKey: key.publicKey,
           },
-          ...(showDeposit !== undefined ? { method: 'register' as const, showDeposit } : {}),
+          ...(method ? { method } : {}),
+          ...(showDeposit !== undefined ? { showDeposit } : {}),
         },
       },
     ],
@@ -237,9 +239,11 @@ describe('Provider.create', () => {
 
       await provider.request(
         connectRequest({
+          method: 'register',
           showDeposit: {
             amount: '50',
             displayName: 'DoorDash',
+            on: 'register',
             token: 'USDC',
           },
         }),
@@ -250,6 +254,7 @@ describe('Provider.create', () => {
           {
             "amount": "50",
             "displayName": "DoorDash",
+            "on": "register",
             "token": "USDC",
           },
         ]
@@ -259,6 +264,45 @@ describe('Provider.create', () => {
     }
   })
 
+  test('behavior: forwards showDeposit through login device-code requests', async () => {
+    const handler = createHandler()
+    const server = await createServer(handler.listener)
+    const pendingShowDeposit: z.output<typeof CliAuth.pendingResponse>['showDeposit'][] = []
+
+    try {
+      const provider = Provider.create({
+        chains: [chain],
+        open: async (url) => {
+          const code = new URL(url).searchParams.get('code')!
+          const response = await fetch(`${server.url}/cli-auth/pending/${code}`)
+          const pending = z.decode(CliAuth.pendingResponse, (await response.json()) as never)
+          pendingShowDeposit.push(pending.showDeposit)
+          await fetch(`${server.url}/cli-auth`, {
+            body: JSON.stringify(await authorizePending(server.url, code)),
+            headers: { 'content-type': 'application/json' },
+            method: 'POST',
+          })
+        },
+        host: `${server.url}/cli-auth`,
+      })
+
+      await provider.request(
+        connectRequest({
+          method: 'login',
+          showDeposit: true,
+        }),
+      )
+
+      expect(pendingShowDeposit).toMatchInlineSnapshot(`
+        [
+          true,
+        ]
+      `)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
   test('behavior: browser-open failures surface the URL and code', async () => {
     const handler = createHandler()
     const server = await createServer(handler.listener)

package/src/core/AccessKey.ts

@@ -251,7 +251,7 @@ export declare namespace authorize {
   /** Options for {@link authorize}. */
   type Options = {
     /** Root account that owns this access key and signs its authorization. */
-    account: TempoAccount.Account
+    account: Pick<TempoAccount.Account, 'address' | 'sign'>
     /** Default chain ID for the authorization when `parameters.chainId` is not set. */
     chainId: bigint | number
     /** Access key authorization parameters. */

package/src/core/Adapter.ts

@@ -245,7 +245,7 @@ export declare namespace loadAccounts {
   type Capabilities = NonNullable<
     NonNullable<Rpc.wallet_connect.Decoded['params']>[number]['capabilities']
   >
-  type ShowDeposit = Extract<Capabilities, { method: 'register' }>['showDeposit']
+  type ShowDeposit = Extract<Capabilities, { method?: 'login' | undefined }>['showDeposit']
 
   type Parameters = {
     /** Grant an access key during the ceremony. */
@@ -263,7 +263,7 @@ export declare namespace loadAccounts {
     personalSign?: { message: string } | undefined
     /** When `true`, prompts the user to pick from all available credentials instead of using the last-used one. */
     selectAccount?: boolean | undefined
-    /** Show the deposit flow after a register ceremony signs in to an existing account. */
+    /** Show the deposit flow after the connect ceremony succeeds. */
     showDeposit?: ShowDeposit | undefined
   }
   type ReturnType = {

package/src/core/Provider.ts

@@ -664,6 +664,9 @@ export function create(options: create.Options = {}): create.ReturnType {
                           authorizeAccessKey,
                           selectAccount: capabilities?.selectAccount,
                           ...(personalSign_request ? { personalSign: personalSign_request } : {}),
+                          ...(capabilities?.showDeposit !== undefined
+                            ? { showDeposit: capabilities.showDeposit }
+                            : {}),
                         },
                         request,
                       )

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

@@ -105,6 +105,7 @@ describe('Encoded', () => {
     type Register = Extract<Capabilities, { method: 'register' }>
     type Login = Extract<Capabilities, { method?: 'login' | undefined }>
     type ShowDeposit = Register['showDeposit']
+    type LoginShowDeposit = Login['showDeposit']
     type ShowDepositObject = Exclude<Exclude<ShowDeposit, boolean | undefined>, undefined>
 
     expectTypeOf<ShowDeposit>().toMatchTypeOf<
@@ -112,11 +113,12 @@ describe('Encoded', () => {
       | {
           amount?: string | undefined
           displayName?: string | undefined
+          on?: 'login' | 'register' | undefined
           token?: string | undefined
         }
       | undefined
     >()
-    expectTypeOf<Login>().not.toHaveProperty('showDeposit')
+    expectTypeOf<LoginShowDeposit>().toEqualTypeOf<ShowDeposit>()
     expectTypeOf<ShowDepositObject>().not.toHaveProperty('address')
     expectTypeOf<ShowDepositObject>().not.toHaveProperty('chainId')
   })

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

@@ -80,10 +80,34 @@ describe('privy', () => {
     `)
   })
 
+  test('default: createAccount can select the active embedded wallet', async () => {
+    const { adapter, client } = setup({ createAddresses: [other] })
+    client.addWallet(other)
+
+    const result = await adapter.actions.createAccount(
+      { digest: '0x1234', name: 'Ada' },
+      { method: 'wallet_connect', params: undefined },
+    )
+
+    expect(client.signWith).toMatchInlineSnapshot(`
+      [
+        "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
+      ]
+    `)
+    expect(result.accounts).toMatchInlineSnapshot(`
+      [
+        {
+          "address": "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
+          "label": "Ada",
+        },
+      ]
+    `)
+  })
+
   test('default: loadAccounts delegates login and caches embedded wallets for signing', async () => {
-    const { adapter, client } = setup()
+    const { adapter, client, store } = setup()
 
-    await adapter.actions.loadAccounts(undefined, { method: 'wallet_connect', params: undefined })
+    await connect({ adapter, store })
     const result = await adapter.actions.signPersonalMessage(
       { address, data: '0x68656c6c6f' },
       { method: 'personal_sign', params: ['0x68656c6c6f', address] },
@@ -100,6 +124,32 @@ describe('privy', () => {
     )
   })
 
+  test('default: loadAccounts can select and order embedded wallets', async () => {
+    const { adapter, client } = setup({ loadAddresses: [other, address] })
+    client.addWallet(other)
+
+    const result = await adapter.actions.loadAccounts(
+      { digest: '0x1234' },
+      { method: 'wallet_connect', params: undefined },
+    )
+
+    expect(client.signWith).toMatchInlineSnapshot(`
+      [
+        "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
+      ]
+    `)
+    expect(result.accounts).toMatchInlineSnapshot(`
+      [
+        {
+          "address": "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
+        },
+        {
+          "address": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+        },
+      ]
+    `)
+  })
+
   test('default: loadAccounts can provision an external access key', async () => {
     const { adapter, client } = setup()
 
@@ -144,6 +194,39 @@ describe('privy', () => {
     `)
   })
 
+  test('default: signs transactions with a materialized Privy account', async () => {
+    const { adapter, client, store } = setup()
+    await connect({ adapter, store })
+
+    const result = await adapter.actions.signTransaction(
+      {
+        chainId: 1,
+        from: address,
+        gas: 21_000n,
+        maxFeePerGas: 1n,
+        maxPriorityFeePerGas: 1n,
+        nonce: 0,
+        to: other,
+        value: 1n,
+      },
+      { method: 'eth_signTransaction', params: [{ from: address }] },
+    )
+
+    expect(client.signWith).toMatchInlineSnapshot(`
+      [
+        "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+      ]
+    `)
+    expect(client.signPayloads).toMatchInlineSnapshot(`
+      [
+        "0x62f087d34b8a023e0461eb1b9a01267ba5b8400c13d2ffdac615ccec872cc288",
+      ]
+    `)
+    expect(result).toMatchInlineSnapshot(
+      `"0x76f86a010101825208d8d7942b5ad5c4795c026514f8317c7a215e218dccd6cf0180c0808080808080c0b8418b0c18077cb78666296a4c0e8149935124f70d7820ec4e4ae81de428659d6c305c098dea43ccb536e813bb1c136eab5e96611de69489be6291169b2bb2318cde1b"`,
+    )
+  })
+
   test('default: authorizeAccessKey signs with the connected Privy account', async () => {
     const { adapter, client, store } = setup()
     store.setState({ accounts: [{ address }], activeAccount: 0 })
@@ -386,6 +469,51 @@ describe('privy', () => {
     expect(store.getState().accounts).toMatchInlineSnapshot(`[]`)
   })
 
+  test('behavior: failed account selection does not poison silent restore cache', async () => {
+    const { adapter, store } = setup({ loadAddresses: [other] })
+    store.setState({ accounts: [{ address: other }], activeAccount: 0 })
+
+    await expect(
+      adapter.actions.loadAccounts(undefined, { method: 'wallet_connect', params: undefined }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Provider.UnauthorizedError: Privy callback returned address "${other}" that was not found in the user's embedded wallets.]`,
+    )
+
+    await expect(
+      adapter.actions.signPersonalMessage(
+        { address: other, data: '0x68656c6c6f' },
+        { method: 'personal_sign', params: ['0x68656c6c6f', other] },
+      ),
+    ).rejects.toMatchInlineSnapshot(
+      '[Provider.DisconnectedError: Privy session no longer matches persisted accounts.]',
+    )
+    expect(store.getState().accounts).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('behavior: failed empty createAccount selection does not poison silent restore cache', async () => {
+    const { adapter, store } = setup({ createAddresses: [] })
+    store.setState({ accounts: [{ address: other }], activeAccount: 0 })
+
+    await expect(
+      adapter.actions.createAccount(
+        { digest: '0x1234', name: 'Ada' },
+        { method: 'wallet_connect', params: undefined },
+      ),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Provider.DisconnectedError: Privy returned no wallet.]`,
+    )
+
+    await expect(
+      adapter.actions.signPersonalMessage(
+        { address: other, data: '0x68656c6c6f' },
+        { method: 'personal_sign', params: ['0x68656c6c6f', other] },
+      ),
+    ).rejects.toMatchInlineSnapshot(
+      '[Provider.DisconnectedError: Privy session no longer matches persisted accounts.]',
+    )
+    expect(store.getState().accounts).toMatchInlineSnapshot(`[]`)
+  })
+
   test('error: silent restore rejects non-hex secp256k1_sign results', async () => {
     const { adapter, store } = setup({ signResult: 'not-hex' })
     store.setState({ accounts: [{ address }], activeAccount: 0 })
@@ -410,8 +538,8 @@ describe('privy', () => {
   })
 
   test('error: malformed secp256k1_sign result is rejected by signer recovery', async () => {
-    const { adapter } = setup({ signResult: '0x1234' })
-    await adapter.actions.loadAccounts(undefined, { method: 'wallet_connect', params: undefined })
+    const { adapter, store } = setup({ signResult: '0x1234' })
+    await connect({ adapter, store })
 
     await expect(
       adapter.actions.signPersonalMessage(
@@ -424,8 +552,8 @@ describe('privy', () => {
   })
 
   test('error: signing for an unconnected address while others are connected throws Unauthorized', async () => {
-    const { adapter } = setup()
-    await adapter.actions.loadAccounts(undefined, { method: 'wallet_connect', params: undefined })
+    const { adapter, store } = setup()
+    await connect({ adapter, store })
 
     await expect(
       adapter.actions.signPersonalMessage(
@@ -478,8 +606,8 @@ describe('privy', () => {
   })
 
   test('error: signature recovered from a different key is rejected as Unauthorized', async () => {
-    const { adapter } = setup({ signWithPrivateKey: privateKeyB })
-    await adapter.actions.loadAccounts(undefined, { method: 'wallet_connect', params: undefined })
+    const { adapter, store } = setup({ signWithPrivateKey: privateKeyB })
+    await connect({ adapter, store })
 
     await expect(
       adapter.actions.signPersonalMessage(
@@ -503,12 +631,12 @@ function setup(options: setup.Options = {}) {
       : {
           createAccount: async () => {
             client.createCalls++
-            return undefined
+            return options.createAddresses
           },
         }),
     loadAccounts: async () => {
       client.loadCalls++
-      return undefined
+      return options.loadAddresses
     },
   })({
     getAccount: (() => {
@@ -527,10 +655,22 @@ function setup(options: setup.Options = {}) {
   return { adapter, client, store }
 }
 
+async function connect(options: Pick<ReturnType<typeof setup>, 'adapter' | 'store'>) {
+  const { adapter, store } = options
+  const loaded = await adapter.actions.loadAccounts(undefined, {
+    method: 'wallet_connect',
+    params: undefined,
+  })
+  store.setState({ accounts: loaded.accounts, activeAccount: 0 })
+  return loaded
+}
+
 declare namespace setup {
   type Options = {
     /** Pass `false` to omit the adapter's `createAccount` callback (tests fallback to `loadAccounts`). */
     createAccount?: false | undefined
+    createAddresses?: readonly Address[] | undefined
+    loadAddresses?: readonly Address[] | undefined
     /** Make the mock client's `user.get` throw, to test restore-side session errors. */
     restoreError?: unknown
     token?: string | null | undefined