rise-wallet 0.1.4-beta.2 → 0.2.29

package/src/core/internal/permissions.ts

@@ -0,0 +1,43 @@
+import type * as Address from 'ox/Address'
+import type * as z from 'zod/mini'
+
+import * as Key from '../../viem/Key.js'
+import * as Permissions_ from './schema/permissions.js'
+
+export const Schema = Permissions_.Permissions
+
+export type Permissions = z.infer<typeof Schema>
+
+export function fromKey(key: Key.Key, options: fromKey.Options): Permissions {
+  const { chainId, expiry, permissions, id, publicKey, type } = key
+  const { address } = options
+  return {
+    address,
+    chainId,
+    expiry,
+    id,
+    key: {
+      publicKey,
+      type,
+    },
+    permissions: (permissions ?? {}) as never,
+  }
+}
+
+export declare namespace fromKey {
+  export type Options = {
+    address: Address.Address
+  }
+}
+
+export function toKey(permissions: Permissions): Key.Key {
+  const { chainId, expiry, key } = permissions
+  return Key.from({
+    chainId,
+    expiry,
+    permissions: permissions.permissions ?? {},
+    publicKey: key.publicKey,
+    role: 'session',
+    type: key.type,
+  })
+}

package/src/core/internal/permissionsRequest.ts

@@ -0,0 +1,88 @@
+import type * as Address from 'ox/Address'
+import type * as Hex from 'ox/Hex'
+import type * as z from 'zod/mini'
+import * as Key from '../../viem/Key.js'
+import * as Permissions from './schema/permissions.js'
+import type * as Tokens from './tokens.js'
+
+export const Schema = Permissions.Request
+
+export type PermissionsRequest = z.infer<typeof Schema>
+
+export function fromKey(key: Key.Key): PermissionsRequest {
+  const { expiry, feeToken, permissions, publicKey, type } = key
+  return {
+    expiry,
+    feeToken: feeToken ?? null,
+    key: {
+      publicKey,
+      type,
+    },
+    permissions: (permissions ?? {}) as never,
+  }
+}
+
+export declare namespace fromKey {
+  export type Options = {
+    address: Address.Address
+    chainId?: Hex.Hex | undefined
+  }
+}
+
+export async function toKey(
+  request: PermissionsRequest | undefined,
+  options: toKey.Options = {},
+): Promise<Key.Key | undefined> {
+  if (!request) return undefined
+
+  const chainId = options.chainId ?? request.chainId
+  const expiry = request.expiry ?? 0
+  const feeToken = request.feeToken
+  const permissions = Key.resolvePermissions(request, {
+    feeTokens: options.feeTokens,
+  })
+  const baseParameters = {
+    chainId,
+    expiry,
+    feeToken,
+    permissions,
+    role: 'session' as const,
+  }
+
+  if (request?.key)
+    return Key.from({
+      ...baseParameters,
+      publicKey: request.key.publicKey,
+      type: request.key.type ?? 'secp256k1',
+    })
+
+  const hasWebCryptoSubtle =
+    typeof globalThis.crypto?.subtle?.generateKey === 'function'
+
+  if (hasWebCryptoSubtle)
+    try {
+      return await Key.createWebCryptoP256(baseParameters)
+    } catch (error) {
+      if (!isWebCryptoUnavailable(error)) throw error
+    }
+
+  return Key.createP256(baseParameters)
+}
+
+export declare namespace toKey {
+  export type Options = {
+    chainId?: number | undefined
+    feeTokens?: Tokens.Tokens | undefined
+  }
+}
+
+function isWebCryptoUnavailable(error: unknown) {
+  if (!(error instanceof Error)) return false
+  const message = error.message?.toLowerCase() ?? ''
+  return (
+    error.name === 'TypeError' ||
+    error.name === 'ReferenceError' ||
+    message.includes('subtle') ||
+    message.includes('generatekey')
+  )
+}

package/src/core/internal/porto.ts

@@ -0,0 +1,16 @@
+import type * as Chains from '../Chains.js'
+import type * as Mode from '../Mode.js'
+import type { Config, Store } from '../Porto.js'
+
+export type Internal<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = {
+  config: Config<chains>
+  id: string
+  getMode: () => Mode.Mode
+  setMode: (i: Mode.Mode) => void
+  store: Store<chains>
+}

package/src/core/internal/promise.ts

@@ -0,0 +1,19 @@
+/** @internal */
+export type PromiseWithResolvers<type> = {
+  promise: Promise<type>
+  resolve: (value: type | PromiseLike<type>) => void
+  reject: (reason?: unknown) => void
+}
+
+/** @internal */
+export function withResolvers<type>(): PromiseWithResolvers<type> {
+  let resolve: PromiseWithResolvers<type>['resolve'] = () => undefined
+  let reject: PromiseWithResolvers<type>['reject'] = () => undefined
+
+  const promise = new Promise<type>((resolve_, reject_) => {
+    resolve = resolve_
+    reject = reject_
+  })
+
+  return { promise, reject, resolve }
+}

package/src/core/internal/provider.browser.test.ts

@@ -0,0 +1,311 @@
+import type { Porto } from 'porto'
+import { waitForCallsStatus } from 'viem/actions'
+import { afterEach, describe, expect, test } from 'vitest'
+import { getPorto } from '../../../test/src/browser/config.js'
+import { interact } from '../../../test/src/browser/utils.js'
+import * as WalletClient from '../../viem/WalletClient.js'
+
+let porto: Porto.Porto | undefined
+afterEach(() => {
+  porto?._internal.store.setState(porto._internal.store.getInitialState())
+  porto?.destroy()
+  window.localStorage.clear()
+  window.sessionStorage.clear()
+  // biome-ignore lint/suspicious/noDocumentCookie: do what i want
+  document.cookie = ''
+})
+
+describe('eth_accounts', () => {
+  test('default', async () => {
+    porto = getPorto()
+
+    await interact(
+      porto.provider.request({ method: 'wallet_connect' }),
+      (iframe) => iframe.getByTestId('sign-up').click(),
+    )
+
+    const accounts = await porto.provider.request({
+      method: 'eth_accounts',
+    })
+    expect(accounts.length).toBe(1)
+  })
+
+  test('behavior: disconnected', async () => {
+    porto = getPorto()
+
+    await expect(
+      porto.provider.request({
+        method: 'eth_accounts',
+      }),
+    ).rejects.toThrowError()
+  })
+})
+
+describe('wallet_connect', () => {
+  test('sign in', async () => {
+    porto = getPorto()
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_connect',
+        params: [{ capabilities: { createAccount: true } }],
+      }),
+      (iframe) => iframe.getByTestId('sign-up').click(),
+    )
+    await porto.provider.request({ method: 'wallet_disconnect' })
+
+    const { accounts } = await interact(
+      porto.provider.request({ method: 'wallet_connect' }),
+      (iframe) => iframe.getByTestId('sign-in').click(),
+    )
+    expect(accounts.length).toBe(1)
+  })
+})
+
+describe('wallet_disconnect', () => {
+  test('default', async () => {
+    porto = getPorto()
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_connect',
+        params: [{ capabilities: { createAccount: true } }],
+      }),
+      (iframe) => iframe.getByTestId('sign-up').click(),
+    )
+
+    const messages: any[] = []
+    porto.provider.on('disconnect', (message) => messages.push(message))
+
+    await porto.provider.request({ method: 'wallet_disconnect' })
+
+    await expect(
+      porto.provider.request({ method: 'eth_accounts' }),
+    ).rejects.toThrowError()
+
+    const accounts2 = porto._internal.store.getState().accounts
+    expect(accounts2.length).toBe(0)
+    expect(messages).toMatchInlineSnapshot(`
+      [
+        [Provider.DisconnectedError: The provider is disconnected from all chains.],
+      ]
+    `)
+  })
+})
+
+describe('wallet_getAdmins', () => {
+  test('default', async () => {
+    porto = getPorto()
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_connect',
+        params: [{ capabilities: { createAccount: true } }],
+      }),
+      (iframe) => iframe.getByTestId('sign-up').click(),
+    )
+
+    const { address, keys } = await porto.provider.request({
+      method: 'wallet_getAdmins',
+    })
+    expect(address).toBeDefined()
+    expect(keys.length).toBe(1)
+  })
+
+  test('behavior: disconnect > connect > getAdmins', async () => {
+    porto = getPorto()
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_connect',
+        params: [{ capabilities: { createAccount: true } }],
+      }),
+      (iframe) => iframe.getByTestId('sign-up').click(),
+    )
+
+    await porto.provider.request({ method: 'wallet_disconnect' })
+
+    await interact(
+      porto.provider.request({ method: 'wallet_connect' }),
+      (iframe) => iframe.getByTestId('sign-in').click(),
+    )
+
+    const { address, keys } = await porto.provider.request({
+      method: 'wallet_getAdmins',
+    })
+    expect(address).toBeDefined()
+    expect(keys.length).toBe(1)
+  })
+})
+
+describe('wallet_getPermissions', () => {
+  test('default', async () => {
+    porto = getPorto()
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_connect',
+        params: [
+          {
+            capabilities: {
+              createAccount: true,
+              grantPermissions: {
+                expiry: 9999999999,
+                feeToken: {
+                  limit: '1',
+                  symbol: 'EXP',
+                },
+                permissions: {
+                  calls: [{ signature: 'mint()' }],
+                },
+              },
+            },
+          },
+        ],
+      }),
+      (iframe) => iframe.getByTestId('sign-up').click(),
+    )
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_grantPermissions',
+        params: [
+          {
+            expiry: 9999999999,
+            feeToken: {
+              limit: '1',
+              symbol: 'EXP',
+            },
+            permissions: { calls: [{ signature: 'mint()' }] },
+          },
+        ],
+      }),
+      (iframe) => iframe.getByTestId('grant').click(),
+    )
+
+    const permissions = await porto.provider.request({
+      method: 'wallet_getPermissions',
+    })
+    expect(permissions.length).toBe(2)
+  })
+
+  test('behavior: grant on connect; grant another; get after connect', async () => {
+    porto = getPorto()
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_connect',
+        params: [
+          {
+            capabilities: {
+              createAccount: true,
+              grantPermissions: {
+                expiry: 9999999999,
+                feeToken: {
+                  limit: '1',
+                  symbol: 'EXP',
+                },
+                key: {
+                  publicKey: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+                  type: 'secp256k1',
+                },
+                permissions: {
+                  calls: [{ signature: 'mint()' }],
+                },
+              },
+            },
+          },
+        ],
+      }),
+      (iframe) => iframe.getByTestId('sign-up').click(),
+    )
+
+    await interact(
+      porto.provider.request({
+        method: 'wallet_grantPermissions',
+        params: [
+          {
+            expiry: 9999999999,
+            feeToken: {
+              limit: '1',
+              symbol: 'EXP',
+            },
+            key: {
+              publicKey:
+                '0xcafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe',
+              type: 'p256',
+            },
+            permissions: {
+              calls: [{ signature: 'mint()' }],
+            },
+          },
+        ],
+      }),
+      (iframe) => iframe.getByTestId('grant').click(),
+    )
+
+    {
+      const permissions = await porto.provider.request({
+        method: 'wallet_getPermissions',
+      })
+      expect(
+        permissions.map((x) => ({
+          ...x,
+          address: null,
+          chainId: null,
+          permissions: {
+            ...x.permissions,
+            calls: x.permissions.calls.map((x) => ({
+              ...x,
+              to: null,
+            })),
+            spend: x.permissions.spend?.map((x) => ({
+              ...x,
+              limit: null,
+              token: null,
+            })),
+          },
+        })),
+      ).matchSnapshot()
+    }
+
+    const { id } = await interact(
+      porto.provider.request({
+        method: 'wallet_sendCalls',
+        params: [{ calls: [] }],
+      }),
+      async (iframe) => {
+        await iframe.getByTestId('buy').click()
+        await iframe.getByTestId('confirm').click()
+      },
+    )
+    await waitForCallsStatus(WalletClient.fromPorto(porto), {
+      id,
+    })
+
+    {
+      const permissions = await porto.provider.request({
+        method: 'wallet_getPermissions',
+      })
+      expect(
+        permissions.map((x) => ({
+          ...x,
+          address: null,
+          chainId: null,
+          permissions: {
+            ...x.permissions,
+            calls: x.permissions.calls.map((x) => ({
+              ...x,
+              to: null,
+            })),
+            spend: x.permissions.spend?.map((x) => ({
+              ...x,
+              limit: null,
+              token: null,
+            })),
+          },
+        })),
+      ).matchSnapshot()
+    }
+  })
+})