rise-wallet 0.1.4-beta.2 → 0.2.29-beta.1

package/src/viem/RelayClient.test.ts

@@ -0,0 +1,127 @@
+import { Porto } from 'rise-wallet'
+import { RelayClient } from 'rise-wallet/viem'
+import { describe, expect, test } from 'vitest'
+
+describe('fromPorto', () => {
+  test('default', async () => {
+    const porto = Porto.create()
+    const client = RelayClient.fromPorto(porto)
+    expect({ ...client, uid: null }).toMatchInlineSnapshot(`
+      {
+        "account": undefined,
+        "batch": undefined,
+        "cacheTime": 1000,
+        "ccipRead": undefined,
+        "chain": {
+          "blockExplorers": {
+            "default": {
+              "apiUrl": "https://api.basescan.org/api",
+              "name": "Basescan",
+              "url": "https://basescan.org",
+            },
+          },
+          "blockTime": 2000,
+          "contracts": {
+            "disputeGameFactory": {
+              "1": {
+                "address": "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e",
+              },
+            },
+            "gasPriceOracle": {
+              "address": "0x420000000000000000000000000000000000000F",
+            },
+            "l1Block": {
+              "address": "0x4200000000000000000000000000000000000015",
+            },
+            "l1StandardBridge": {
+              "1": {
+                "address": "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
+                "blockCreated": 17482143,
+              },
+            },
+            "l2CrossDomainMessenger": {
+              "address": "0x4200000000000000000000000000000000000007",
+            },
+            "l2Erc721Bridge": {
+              "address": "0x4200000000000000000000000000000000000014",
+            },
+            "l2OutputOracle": {
+              "1": {
+                "address": "0x56315b90c40730925ec5485cf004d835058518A0",
+              },
+            },
+            "l2StandardBridge": {
+              "address": "0x4200000000000000000000000000000000000010",
+            },
+            "l2ToL1MessagePasser": {
+              "address": "0x4200000000000000000000000000000000000016",
+            },
+            "multicall3": {
+              "address": "0xca11bde05977b3631167028862be2a173976ca11",
+              "blockCreated": 5022,
+            },
+            "portal": {
+              "1": {
+                "address": "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
+                "blockCreated": 17482143,
+              },
+            },
+          },
+          "fees": undefined,
+          "formatters": {
+            "block": {
+              "exclude": undefined,
+              "format": [Function],
+              "type": "block",
+            },
+            "transaction": {
+              "exclude": undefined,
+              "format": [Function],
+              "type": "transaction",
+            },
+            "transactionReceipt": {
+              "exclude": undefined,
+              "format": [Function],
+              "type": "transactionReceipt",
+            },
+          },
+          "id": 8453,
+          "name": "Base",
+          "nativeCurrency": {
+            "decimals": 18,
+            "name": "Ether",
+            "symbol": "ETH",
+          },
+          "rpcUrls": {
+            "default": {
+              "http": [
+                "https://mainnet.base.org",
+              ],
+            },
+          },
+          "serializers": {
+            "transaction": [Function],
+          },
+          "sourceId": 1,
+        },
+        "extend": [Function],
+        "key": "base",
+        "name": "Base Client",
+        "pollingInterval": 1000,
+        "request": [Function],
+        "transport": {
+          "key": "relayProxy",
+          "methods": undefined,
+          "name": "Relay Proxy",
+          "request": [Function],
+          "retryCount": 3,
+          "retryDelay": 150,
+          "timeout": undefined,
+          "type": "relayProxy",
+        },
+        "type": "base",
+        "uid": null,
+      }
+    `)
+  })
+})

package/src/viem/RelayClient.ts

@@ -0,0 +1,87 @@
+import * as Json from 'ox/Json'
+import {
+  type ClientConfig,
+  createClient,
+  fallback,
+  http,
+  type Client as viem_Client,
+} from 'viem'
+import type * as Chains from '../core/Chains.js'
+import type { Internal } from '../core/internal/porto.js'
+import * as Transport from '../core/Transport.js'
+import type * as Account from './Account.js'
+import type * as RpcSchema from './RpcSchema.js'
+
+export type RelayClient<
+  transport extends Transport.Transport = Transport.Transport,
+  chain extends Chains.Chain = Chains.Chain,
+  account extends Account.Account | undefined = Account.Account | undefined,
+> = viem_Client<transport, chain, account, RpcSchema.Relay>
+
+const clientCache = new Map<string, any>()
+
+/**
+ * Extracts a Viem Client from a Porto instance, and an optional chain ID.
+ * By default, the Client for the current chain ID will be extracted.
+ *
+ * @param porto - Porto instance.
+ * @param parameters - Parameters.
+ * @returns Client.
+ */
+export function fromPorto<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+  account extends Account.Account | undefined = undefined,
+>(
+  porto: { _internal: Internal<chains> },
+  config: fromPorto.Config<chains, account> = {},
+): RelayClient<Transport.Transport, chains[number], account> {
+  const { config: config_, id, store } = porto._internal
+  const { chains, relay } = config_
+
+  const state = store.getState()
+  const chainId = config.chainId ?? state.chainIds[0]
+  const chain = chains.find((chain) => chain.id === chainId)
+  if (!chain)
+    throw new Error(
+      [
+        'Could not find a compatible Porto chain on the given chain configuration.',
+        '',
+        `Provided chains: [${chains.map((chain) => `${chain.name} (id: ${chain.id})`).join(', ')}]`,
+        `Needed chain (id): ${chainId}`,
+        'Please add this chain (id) to your chain configuration.',
+      ].join('\n'),
+    )
+
+  const transport = Transport.relayProxy({
+    public:
+      (config_.transports as Record<number, Transport.Transport>)[chain.id] ??
+      fallback(chain.rpcUrls.default.http.map((url) => http(url))),
+    relay,
+  })
+
+  const key = [id, Json.stringify(chain)].filter(Boolean).join(':')
+  if (clientCache.has(key)) return clientCache.get(key)!
+  const client = createClient({
+    ...config,
+    chain,
+    pollingInterval: 1_000,
+    transport,
+  })
+  clientCache.set(key, client)
+  return client as never
+}
+
+export declare namespace fromPorto {
+  type Config<
+    chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+      Chains.Chain,
+      ...Chains.Chain[],
+    ],
+    account extends Account.Account | undefined = Account.Account | undefined,
+  > = Pick<
+    ClientConfig<Transport.Transport, Chains.Chain | undefined, account>,
+    'account' | 'cacheTime' | 'key' | 'name' | 'pollingInterval'
+  > & {
+    chainId?: chains[number]['id'] | undefined
+  }
+}

package/src/viem/RpcSchema.ts

@@ -0,0 +1,27 @@
+import type * as RpcSchema_ox from 'ox/RpcSchema'
+import type { PublicRpcSchema } from 'viem'
+import type { Schema as Schema_relay } from '../core/internal/relay/rpcSchema.js'
+import type { UnionToTuple } from '../core/internal/types.js'
+import type { Schema } from '../core/RpcSchema.js'
+
+export type Relay = [...PublicRpcSchema, ...ToViem<Schema_relay>]
+
+export type Wallet = [
+  ...PublicRpcSchema,
+  ...ToViem<Exclude<Schema, RpcSchema_ox.Eth>>,
+]
+
+type ToViem<schema extends RpcSchema_ox.Generic> =
+  UnionToTuple<schema> extends [
+    infer head extends RpcSchema_ox.Generic,
+    ...infer tail extends RpcSchema_ox.Generic[],
+  ]
+    ? [
+        {
+          Method: head['Request']['method']
+          Parameters: head['Request']['params']
+          ReturnType: head['ReturnType']
+        },
+        ...ToViem<tail[number]>,
+      ]
+    : []