rise-wallet 0.1.4-beta.1 → 0.2.28

package/src/remote/Porto.ts

@@ -0,0 +1,144 @@
+import type * as RpcRequest from 'ox/RpcRequest'
+import { createStore, type StoreApi } from 'zustand/vanilla'
+
+import type * as Chains from '../core/Chains.js'
+import type { ExactPartial, OneOf } from '../core/internal/types.js'
+import * as Messenger from '../core/Messenger.js'
+import * as Mode from '../core/Mode.js'
+import * as Porto_ from '../core/Porto.js'
+import type * as RpcSchema from '../core/RpcSchema.js'
+import * as Storage from '../core/Storage.js'
+import { hostnames } from '../trusted-hosts.js'
+import * as MethodPolicies from './internal/methodPolicies.js'
+
+const messenger = (() => {
+  if (typeof window === 'undefined') return Messenger.noop()
+
+  const url = new URL(window.location.href)
+  const relayUrl = url.searchParams.get('relayUrl')
+  if (relayUrl) return Messenger.cliRelay({ relayUrl })
+
+  return Messenger.bridge({
+    from: Messenger.fromWindow(window),
+    to: Messenger.fromWindow(window.opener ?? window.parent),
+  })
+})() as Messenger.Bridge | Messenger.Messenger
+
+export const defaultConfig = {
+  ...Porto_.defaultConfig,
+  messenger,
+  methodPolicies: MethodPolicies.methodPolicies,
+  mode: Mode.relay(),
+  storage: Storage.localStorage(),
+  trustedHosts: hostnames,
+} as const satisfies Partial<Config>
+
+/**
+ * Instantiates an Porto instance to be used in a remote context (e.g. an iframe or popup).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Porto } from 'porto/remote'
+ * const porto = Porto.create()
+ * ```
+ */
+export function create<
+  const chains extends readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ] = typeof defaultConfig.chains,
+>(parameters?: ExactPartial<Config<chains>> | undefined): Porto<chains>
+export function create(
+  parameters: ExactPartial<Config> | undefined = {},
+): Porto {
+  const {
+    chains = defaultConfig.chains,
+    feeToken,
+    mode = defaultConfig.mode,
+    messenger = defaultConfig.messenger,
+    methodPolicies = defaultConfig.methodPolicies,
+    merchantUrl,
+    relay = defaultConfig.relay,
+    storage = defaultConfig.storage,
+    storageKey = defaultConfig.storageKey,
+    transports,
+    trustedHosts = defaultConfig.trustedHosts,
+  } = parameters
+
+  const porto = Porto_.create({
+    announceProvider: false,
+    chains,
+    feeToken,
+    merchantUrl,
+    mode,
+    relay,
+    storage,
+    storageKey,
+    transports,
+  })
+
+  const remoteStore = createStore<RemoteState>(() => ({
+    requests: [],
+  }))
+
+  return {
+    ...porto,
+    _internal: {
+      ...porto._internal,
+      remoteStore,
+    },
+    messenger,
+    methodPolicies,
+    mode,
+    async ready() {
+      await porto._internal.store.persist.rehydrate()
+      const { chainIds } = porto._internal.store.getState()
+
+      if (!('ready' in messenger)) return
+      return (messenger as Messenger.WithReady).ready({
+        chainIds,
+        methodPolicies,
+        trustedHosts,
+      })
+    },
+  } as unknown as Porto
+}
+
+export type Porto<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = Porto_.Porto<chains> & {
+  mode: Mode.Mode
+  messenger: OneOf<Messenger.WithReady | Messenger.Messenger>
+  methodPolicies?: MethodPolicies.MethodPolicies | undefined
+  ready: () => Promise<void>
+  _internal: Porto_.Porto<chains>['_internal'] & {
+    remoteStore: StoreApi<RemoteState>
+  }
+}
+
+export type Config<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = Porto_.Config<chains> & {
+  messenger?: OneOf<Messenger.Bridge | Messenger.Messenger> | undefined
+  methodPolicies?: MethodPolicies.MethodPolicies | undefined
+  trustedHosts?: string[] | undefined
+}
+
+export type State<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = Porto_.State<chains>
+
+export type RemoteState = {
+  requests: readonly (Porto_.QueuedRequest & {
+    request: RpcRequest.RpcRequest<RpcSchema.Schema>
+  })[]
+}

package/src/remote/index.ts

@@ -0,0 +1,4 @@
+export * as Actions from './Actions.js'
+export * as Events from './Events.js'
+export * as Hooks from './Hooks.js'
+export * as Porto from './Porto.js'

package/src/remote/internal/methodPolicies.ts

@@ -0,0 +1,124 @@
+import * as UserAgent from '../../core/internal/userAgent.js'
+
+export type MethodPolicy = {
+  method: string
+  modes?:
+    | {
+        headless?:
+          | true
+          | {
+              sameOrigin?: boolean | undefined
+            }
+          | undefined
+        dialog?:
+          | true
+          | {
+              sameOrigin?: boolean | undefined
+            }
+          | undefined
+      }
+    | undefined
+  requireConnection?: boolean | undefined
+}
+export type MethodPolicies = readonly MethodPolicy[]
+
+export const methodPolicies = [
+  {
+    method: 'eth_requestAccounts',
+    modes: {
+      dialog: true,
+      headless: {
+        sameOrigin: true,
+      },
+    },
+    requireConnection: false,
+  },
+  {
+    method: 'wallet_getAccountVersion',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_getKeys',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_getPermissions',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_grantAdmin',
+    modes: {
+      dialog: {
+        sameOrigin: true,
+      },
+    },
+  },
+  {
+    method: 'wallet_revokeAdmin',
+    modes: {
+      dialog: {
+        sameOrigin: true,
+      },
+    },
+  },
+  {
+    method: 'wallet_upgradeAccount',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_connect',
+    modes: {
+      dialog: true,
+      headless: !UserAgent.isSafari()
+        ? {
+            sameOrigin: true,
+          }
+        : undefined,
+    },
+    requireConnection: false,
+  },
+  {
+    method: 'wallet_getAssets',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_getCallsStatus',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_getCapabilities',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_prepareCalls',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_sendPreparedCalls',
+    modes: {
+      headless: true,
+    },
+  },
+  {
+    method: 'wallet_switchEthereumChain',
+    modes: {
+      headless: true,
+    },
+  },
+] as const satisfies MethodPolicies

package/src/server/Route.test.ts

@@ -0,0 +1,347 @@
+import { Hex, Value } from 'ox'
+import { Key } from 'porto'
+import { Route } from 'porto/server'
+import { readContract, waitForCallsStatus } from 'viem/actions'
+import { describe, expect, test } from 'vitest'
+import * as TestActions from '../../test/src/actions.js'
+import * as TestConfig from '../../test/src/config.js'
+import * as Http from '../../test/src/http.js'
+import type { ExactPartial } from '../core/internal/types.js'
+import * as RelayActions from '../viem/RelayActions.js'
+
+const porto = TestConfig.getPorto()
+const client = TestConfig.getRelayClient(porto)
+const contracts = await TestConfig.getContracts(porto)
+
+describe('merchant', () => {
+  let server: Http.Server | undefined
+  async function setup(options: ExactPartial<Route.merchant.Options> = {}) {
+    const merchantKey = Key.createSecp256k1()
+    const merchantAccount = await TestActions.createAccount(client, {
+      deploy: true,
+      keys: [merchantKey],
+    })
+
+    const route = Route.merchant({
+      ...porto.config,
+      ...options,
+      address: merchantAccount.address,
+      key: merchantKey.privateKey!(),
+    })
+
+    if (server) await server.closeAsync()
+    server = await Http.createServer(route.listener)
+
+    return { merchantAccount, route, server }
+  }
+
+  test('behavior: simple sponsor', async () => {
+    const { server, merchantAccount } = await setup()
+
+    const userKey = Key.createHeadlessWebAuthnP256()
+    const userAccount = await TestActions.createAccount(client, {
+      keys: [userKey],
+    })
+
+    const userBalance_pre = await readContract(client, {
+      ...contracts.exp1,
+      args: [userAccount.address],
+      functionName: 'balanceOf',
+    })
+    const merchantBalance_pre = await readContract(client, {
+      ...contracts.exp1,
+      args: [merchantAccount.address],
+      functionName: 'balanceOf',
+    })
+
+    const result = await RelayActions.sendCalls(client, {
+      account: userAccount,
+      calls: [
+        {
+          abi: contracts.exp1.abi,
+          args: [userAccount.address, Value.fromEther('1')],
+          functionName: 'mint',
+          to: contracts.exp1.address,
+        },
+      ],
+      merchantUrl: server.url,
+    })
+
+    await waitForCallsStatus(client, {
+      id: result.id,
+    })
+
+    const userBalance_post = await readContract(client, {
+      ...contracts.exp1,
+      args: [userAccount.address],
+      functionName: 'balanceOf',
+    })
+    const merchantBalance_post = await readContract(client, {
+      ...contracts.exp1,
+      args: [merchantAccount.address],
+      functionName: 'balanceOf',
+    })
+
+    // Check if user was credited with 1 EXP.
+    expect(userBalance_post).toBe(userBalance_pre + Value.fromEther('1'))
+
+    // Check if merchant was debited the fee payment.
+    expect(merchantBalance_post).toBeLessThan(merchantBalance_pre)
+  })
+
+  test('behavior: conditional sponsoring', async () => {
+    const { server, merchantAccount } = await setup({
+      sponsor: (request) =>
+        // Only sponsor calls targeting the exp1Address
+        request.calls.every((call) => call.to === contracts.exp1.address),
+    })
+
+    const userKey = Key.createHeadlessWebAuthnP256()
+    const userAccount = await TestActions.createAccount(client, {
+      keys: [userKey],
+    })
+
+    {
+      // Test 1: Calls satisfy the sponsor condition.
+      const userBalance_pre = await readContract(client, {
+        ...contracts.exp1,
+        args: [userAccount.address],
+        functionName: 'balanceOf',
+      })
+      const merchantBalance_pre = await readContract(client, {
+        ...contracts.exp1,
+        args: [merchantAccount.address],
+        functionName: 'balanceOf',
+      })
+
+      const result = await RelayActions.sendCalls(client, {
+        account: userAccount,
+        calls: [
+          {
+            abi: contracts.exp1.abi,
+            args: [userAccount.address, Value.fromEther('1')],
+            functionName: 'mint',
+            to: contracts.exp1.address,
+          },
+        ],
+        merchantUrl: server.url,
+      })
+
+      await waitForCallsStatus(client, {
+        id: result.id,
+      })
+
+      const userBalance_post = await readContract(client, {
+        ...contracts.exp1,
+        args: [userAccount.address],
+        functionName: 'balanceOf',
+      })
+      const merchantBalance_post = await readContract(client, {
+        ...contracts.exp1,
+        args: [merchantAccount.address],
+        functionName: 'balanceOf',
+      })
+
+      // Check if user was credited with 1 EXP.
+      expect(userBalance_post).toBe(userBalance_pre + Value.fromEther('1'))
+
+      // Check if merchant was debited the fee payment.
+      expect(merchantBalance_post).toBeLessThan(merchantBalance_pre)
+    }
+
+    {
+      // Test 2: Calls do not satisfy the sponsor condition.
+      const userBalance_pre = await readContract(client, {
+        ...contracts.exp2,
+        args: [userAccount.address],
+        functionName: 'balanceOf',
+      })
+      const merchantBalance_pre = await readContract(client, {
+        ...contracts.exp1,
+        args: [merchantAccount.address],
+        functionName: 'balanceOf',
+      })
+
+      const result = await RelayActions.sendCalls(client, {
+        account: userAccount,
+        calls: [
+          {
+            abi: contracts.exp2.abi,
+            args: [userAccount.address, Value.fromEther('1')],
+            functionName: 'mint',
+            to: contracts.exp2.address,
+          },
+        ],
+        merchantUrl: server.url,
+      })
+
+      await waitForCallsStatus(client, {
+        id: result.id,
+      })
+
+      const userBalance_post = await readContract(client, {
+        ...contracts.exp2,
+        args: [userAccount.address],
+        functionName: 'balanceOf',
+      })
+      const merchantBalance_post = await readContract(client, {
+        ...contracts.exp1,
+        args: [merchantAccount.address],
+        functionName: 'balanceOf',
+      })
+
+      // Check if user was credited with 1 EXP.
+      expect(userBalance_post).toBe(userBalance_pre + Value.fromEther('1'))
+
+      // Check if merchant was NOT debited the fee payment.
+      expect(merchantBalance_post).toEqual(merchantBalance_pre)
+    }
+  })
+
+  // TODO: unskip when merchant account works with interop
+  test.skip('behavior: sponsor w/ required funds', async () => {
+    const { server, merchantAccount } = await setup()
+
+    const chain_dest = TestConfig.chains[1]
+    const client_dest = TestConfig.getRelayClient(porto, {
+      chainId: chain_dest!.id,
+    })
+
+    // Deploy merchant account on destination chain.
+    const { id } = await RelayActions.sendCalls(client_dest, {
+      account: merchantAccount,
+      calls: [],
+    })
+    await waitForCallsStatus(client_dest, {
+      id,
+    })
+
+    await TestActions.setBalance(client_dest, {
+      address: merchantAccount.address,
+    })
+
+    const userKey = Key.createHeadlessWebAuthnP256()
+    const userAccount = await TestActions.createAccount(client, {
+      keys: [userKey],
+    })
+
+    const userBalance_pre = await readContract(client, {
+      ...contracts.exp1,
+      args: [userAccount.address],
+      functionName: 'balanceOf',
+    })
+    const merchantBalance_pre = await readContract(client, {
+      ...contracts.exp1,
+      args: [merchantAccount.address],
+      functionName: 'balanceOf',
+    })
+
+    const alice = Hex.random(20)
+
+    const result = await RelayActions.sendCalls(client, {
+      account: userAccount,
+      calls: [
+        {
+          abi: contracts.exp1.abi,
+          args: [alice, Value.fromEther('50')],
+          functionName: 'transfer',
+          to: contracts.exp1.address,
+        },
+      ],
+      chain: chain_dest,
+      merchantUrl: server.url,
+      requiredFunds: [
+        {
+          address: contracts.exp1.address,
+          value: Value.fromEther('50'),
+        },
+      ],
+    })
+
+    await waitForCallsStatus(client, {
+      id: result.id,
+    })
+
+    const userBalance_post = await readContract(client, {
+      ...contracts.exp1,
+      args: [userAccount.address],
+      functionName: 'balanceOf',
+    })
+    const merchantBalance_post = await readContract(client, {
+      ...contracts.exp1,
+      args: [merchantAccount.address],
+      functionName: 'balanceOf',
+    })
+
+    // Check if user was credited with 1 EXP.
+    expect(userBalance_post).toBeLessThanOrEqual(
+      userBalance_pre - Value.fromEther('50'),
+    )
+
+    // Check if merchant was debited the fee payment.
+    expect(merchantBalance_post).toBeLessThan(merchantBalance_pre)
+  })
+
+  test('behavior: route response (GET)', async () => {
+    const { route } = await setup()
+
+    const response = await route.hono.request('http://localhost')
+    expect(response.status).toBe(200)
+    expect(response.headers.get('access-control-allow-origin')).toBe('*')
+    expect(await response.text()).toBe('ok')
+  })
+
+  test('error: contract error', async () => {
+    const { server } = await setup()
+
+    const userKey = Key.createHeadlessWebAuthnP256()
+    const userAccount = await TestActions.createAccount(client, {
+      keys: [userKey],
+    })
+
+    await expect(() =>
+      RelayActions.sendCalls(client, {
+        account: userAccount,
+        calls: [
+          {
+            abi: contracts.exp1.abi,
+            args: [
+              '0x0000000000000000000000000000000000000000',
+              userAccount.address,
+              Value.fromEther('1'),
+            ],
+            functionName: 'transferFrom',
+            to: contracts.exp1.address,
+          },
+        ],
+        merchantUrl: server.url,
+      }),
+    ).rejects.toThrowError('InsufficientAllowance')
+  })
+
+  test('error: invalid params', async () => {
+    const { server } = await setup()
+
+    const response = await fetch(server.url, {
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'wallet_prepareCalls',
+        params: ['foo'],
+      }),
+      method: 'POST',
+    }).then((r) => r.json())
+    expect(response).toMatchInlineSnapshot(`
+      {
+        "error": {
+          "code": -32602,
+          "message": "Validation failed with 1 error:
+
+      - at \`params[0]\`: Expected object. ",
+        },
+        "id": 1,
+        "jsonrpc": "2.0",
+      }
+    `)
+  })
+})