rise-wallet 0.1.4-beta.2 → 0.2.29

package/src/core/internal/siwe.ts

@@ -0,0 +1,144 @@
+import type * as Address from 'ox/Address'
+import type * as Hex from 'ox/Hex'
+import * as Siwe from 'ox/Siwe'
+import type { Chain, Client, Transport } from 'viem'
+import type * as Capabilities from './schema/capabilities.js'
+
+/** Set of authentication endpoints. */
+export type AuthUrl = {
+  /** Endpoint to logout the user. (e.g. `/logout`) */
+  logout: string
+  /** Endpoint to generate a nonce. (e.g. `/nonce`) */
+  nonce: string
+  /** Endpoint to verify the signature, and authenticate the user. (e.g. `/verify`) */
+  verify: string
+}
+
+export async function authenticate(
+  parameters: authenticate.Parameters,
+): Promise<authenticate.ReturnType> {
+  const { address, authUrl, message, signature } = parameters
+
+  const { chainId } = Siwe.parseMessage(message)
+
+  return await fetch(authUrl.verify, {
+    body: JSON.stringify({
+      address,
+      chainId,
+      message,
+      signature,
+      walletAddress: address,
+    }),
+    credentials: 'include',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+  }).then((res) => res.json())
+}
+
+export declare namespace authenticate {
+  type Parameters = {
+    address: Address.Address
+    authUrl: AuthUrl
+    message: string
+    signature: Hex.Hex
+  }
+
+  type ReturnType = {
+    token?: string | undefined
+  }
+}
+
+export async function buildMessage<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  siwe: Capabilities.signInWithEthereum.Request,
+  options: buildMessage.Options,
+) {
+  const {
+    chainId = client.chain?.id,
+    domain,
+    uri,
+    resources,
+    version = '1',
+  } = siwe
+  const { address } = options
+
+  const authUrl = siwe.authUrl ? resolveAuthUrl(siwe.authUrl) : undefined
+
+  if (!chainId) throw new Error('`chainId` is required.')
+  if (!domain) throw new Error('`domain` is required.')
+  if (!siwe.nonce && !authUrl?.nonce)
+    throw new Error('`nonce` or `authUrl.nonce` is required.')
+  if (!uri) throw new Error('`uri` is required.')
+
+  const nonce = await (async () => {
+    if (siwe.nonce) return siwe.nonce
+    if (!authUrl?.nonce)
+      throw new Error('`nonce` or `authUrl.nonce` is required.')
+    const response = await fetch(authUrl.nonce, {
+      body: JSON.stringify({
+        address,
+        chainId,
+        walletAddress: address,
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      method: 'POST',
+    })
+    const res = await response.json().catch(() => undefined)
+    if (!res?.nonce) throw new Error('`nonce` or `authUrl.nonce` is required.')
+    return res.nonce
+  })()
+
+  const message = Siwe.createMessage({
+    ...siwe,
+    address: options.address,
+    chainId,
+    domain,
+    nonce,
+    resources: resources as string[] | undefined,
+    uri,
+    version,
+  })
+
+  return message
+}
+
+export declare namespace buildMessage {
+  type Options = {
+    address: Address.Address
+  }
+}
+
+export function resolveAuthUrl(
+  authUrl: string | AuthUrl,
+  origin = '',
+): AuthUrl | undefined {
+  if (!authUrl) return undefined
+
+  const urls = (() => {
+    if (typeof authUrl === 'string') {
+      const url = authUrl.replace(/\/$/, '')
+      return {
+        logout: url + '/logout',
+        nonce: url + '/nonce',
+        verify: url + '/verify',
+      }
+    }
+    return authUrl
+  })()
+
+  return {
+    logout: resolveUrl(urls.logout, origin),
+    nonce: resolveUrl(urls.nonce, origin),
+    verify: resolveUrl(urls.verify, origin),
+  }
+}
+
+function resolveUrl(url: string, origin: string) {
+  if (!origin) return url
+  if (!url.startsWith('/')) return url
+  return origin + url
+}

package/src/core/internal/store.ts

@@ -0,0 +1,9 @@
+import type * as Porto from '../Porto.js'
+
+export async function waitForHydration(store: Porto.Store) {
+  if (store.persist.hasHydrated()) return
+  await new Promise((resolve) => {
+    store.persist.onFinishHydration(() => resolve(true))
+    setTimeout(() => resolve(true), 100)
+  })
+}

package/src/core/internal/tokens.test.ts

@@ -0,0 +1,317 @@
+import { describe, expect, test } from 'vitest'
+import * as Anvil from '../../../test/src/anvil.js'
+import * as TestConfig from '../../../test/src/config.js'
+import * as Chains from '../Chains.js'
+import * as Tokens from './tokens.js'
+
+describe.runIf(!Anvil.enabled)('getTokens', () => {
+  test('default', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const tokens = await Tokens.getTokens(client)
+
+    expect(
+      tokens
+        .toSorted((a, b) => a.symbol.localeCompare(b.symbol))
+        .map((x) => ({ ...x, nativeRate: null })),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "address": "0x0000000000000000000000000000000000000000",
+          "decimals": 18,
+          "feeToken": true,
+          "interop": true,
+          "nativeRate": null,
+          "symbol": "ETH",
+          "uid": "teth",
+        },
+        {
+          "address": "0xfca413a634c4df6b98ebb970a44d9a32f8f5c64e",
+          "decimals": 18,
+          "feeToken": true,
+          "interop": true,
+          "nativeRate": null,
+          "symbol": "EXP",
+          "uid": "exp1",
+        },
+        {
+          "address": "0xacb60ce1e9d71c15a34c3afd903f552520b4a28f",
+          "decimals": 18,
+          "feeToken": true,
+          "interop": true,
+          "nativeRate": null,
+          "symbol": "EXP2",
+          "uid": "exp2",
+        },
+      ]
+    `)
+  })
+
+  test('behavior: chain', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const tokens = await Tokens.getTokens(client, { chain: Chains.polygon })
+
+    expect(
+      tokens
+        .toSorted((a, b) => a.symbol.localeCompare(b.symbol))
+        .map((x) => ({ ...x, nativeRate: null })),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "address": "0x0000000000000000000000000000000000000000",
+          "decimals": 18,
+          "feeToken": true,
+          "interop": false,
+          "nativeRate": null,
+          "symbol": "POL",
+          "uid": "matic-network",
+        },
+        {
+          "address": "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
+          "decimals": 6,
+          "feeToken": true,
+          "interop": true,
+          "nativeRate": null,
+          "symbol": "USDC",
+          "uid": "usd-coin",
+        },
+        {
+          "address": "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
+          "decimals": 6,
+          "feeToken": true,
+          "interop": true,
+          "nativeRate": null,
+          "symbol": "USDT0",
+          "uid": "tether",
+        },
+      ]
+    `)
+  })
+})
+
+describe.runIf(!Anvil.enabled)('getToken', () => {
+  test('param: addressOrSymbol (as symbol)', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const token = await Tokens.getToken(client, { addressOrSymbol: 'EXP' })
+
+    expect({ ...token, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0xfca413a634c4df6b98ebb970a44d9a32f8f5c64e",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": true,
+        "nativeRate": null,
+        "symbol": "EXP",
+        "uid": "exp1",
+      }
+    `)
+  })
+
+  test('param: addressOrSymbol (as native)', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const token = await Tokens.getToken(client, {
+      addressOrSymbol: 'native',
+      chain: Chains.polygon,
+    })
+
+    expect({ ...token, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": false,
+        "nativeRate": null,
+        "symbol": "POL",
+        "uid": "matic-network",
+      }
+    `)
+  })
+
+  test('param: addressOrSymbol (as address)', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const token = await Tokens.getToken(client, {
+      addressOrSymbol: '0x0000000000000000000000000000000000000000',
+    })
+
+    expect({ ...token, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": true,
+        "nativeRate": null,
+        "symbol": "ETH",
+        "uid": "teth",
+      }
+    `)
+  })
+})
+
+describe.runIf(!Anvil.enabled)('resolveFeeToken', () => {
+  test('behavior: with store', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    porto._internal.store.setState({
+      feeToken: 'EXP',
+    })
+
+    const feeToken = await Tokens.resolveFeeToken(client, {
+      store: porto._internal.store,
+    })
+
+    expect({ ...feeToken, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0xfca413a634c4df6b98ebb970a44d9a32f8f5c64e",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": true,
+        "nativeRate": null,
+        "symbol": "EXP",
+        "uid": "exp1",
+      }
+    `)
+  })
+
+  test('param: feeToken (as symbol)', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const feeToken = await Tokens.resolveFeeToken(client, {
+      addressOrSymbol: 'ETH',
+      store: porto._internal.store,
+    })
+
+    expect({ ...feeToken, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": true,
+        "nativeRate": null,
+        "symbol": "ETH",
+        "uid": "teth",
+      }
+    `)
+  })
+
+  test('param: feeToken (as native)', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const feeToken = await Tokens.resolveFeeToken(client, {
+      addressOrSymbol: 'native',
+      chain: Chains.polygon,
+      store: porto._internal.store,
+    })
+
+    expect({ ...feeToken, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": false,
+        "nativeRate": null,
+        "symbol": "POL",
+        "uid": "matic-network",
+      }
+    `)
+  })
+
+  test('param: feeToken (as address)', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const feeToken = await Tokens.resolveFeeToken(client, {
+      addressOrSymbol: '0x0000000000000000000000000000000000000000',
+      store: porto._internal.store,
+    })
+
+    expect({ ...feeToken, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": true,
+        "nativeRate": null,
+        "symbol": "ETH",
+        "uid": "teth",
+      }
+    `)
+  })
+
+  test('param: feeToken (as address)', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    const feeToken = await Tokens.resolveFeeToken(client, {
+      addressOrSymbol: '0xfCA413a634C4dF6B98ebb970A44d9a32F8f5c64E',
+      store: porto._internal.store,
+    })
+
+    expect({ ...feeToken, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0xfca413a634c4df6b98ebb970a44d9a32f8f5c64e",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": true,
+        "nativeRate": null,
+        "symbol": "EXP",
+        "uid": "exp1",
+      }
+    `)
+  })
+
+  test('behavior: default fee token', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    porto._internal.store.setState({
+      feeToken: 'ETH',
+    })
+
+    const feeToken = await Tokens.resolveFeeToken(client, {
+      store: porto._internal.store,
+    })
+
+    expect({ ...feeToken, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "decimals": 18,
+        "feeToken": true,
+        "interop": true,
+        "nativeRate": null,
+        "symbol": "ETH",
+        "uid": "teth",
+      }
+    `)
+  })
+
+  test('behavior: falls back to storage fee token if override/default not found', async () => {
+    const porto = TestConfig.getPorto()
+    const client = TestConfig.getRelayClient(porto)
+
+    porto._internal.store.setState({
+      feeToken: 'EXP',
+    })
+
+    const feeToken = await Tokens.resolveFeeToken(client, {
+      addressOrSymbol: 'WAGMI',
+      store: porto._internal.store,
+    })
+    expect({ ...feeToken, nativeRate: null }).toMatchInlineSnapshot(`
+      {
+        "nativeRate": null,
+      }
+    `)
+  })
+})

package/src/core/internal/tokens.ts

@@ -0,0 +1,125 @@
+import * as Address from 'ox/Address'
+import { type Client, type Transport, zeroAddress } from 'viem'
+import type { GetChainParameter } from '../../viem/internal/utils.js'
+import * as RelayActions from '../../viem/RelayActions.js'
+import type * as Chains from '../Chains.js'
+import type { State, Store } from '../Porto.js'
+import type * as Token from './schema/token.js'
+
+export type { Token } from './schema/token.js'
+export type Tokens = readonly Token.Token[]
+
+/**
+ * Fetches all supported tokens for a given chain.
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Tokens.
+ */
+export async function getTokens<chain extends Chains.Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters?: getTokens.Parameters<chain>,
+): Promise<getTokens.ReturnType> {
+  const { chain = client.chain } = parameters ?? {}
+
+  const tokens = await RelayActions.getCapabilities(client, {
+    chainId: chain?.id,
+  }).then((capabilities) => capabilities.fees.tokens)
+
+  return tokens
+}
+
+export declare namespace getTokens {
+  export type Parameters<
+    chain extends Chains.Chain | undefined = Chains.Chain | undefined,
+  > = GetChainParameter<chain>
+
+  export type ReturnType = readonly Token.Token[]
+}
+
+/**
+ * Fetches a token for a given chain, provided an address or symbol.
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Token.
+ */
+export async function getToken<chain extends Chains.Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: getToken.Parameters<chain>,
+): Promise<getToken.ReturnType> {
+  const { addressOrSymbol } = parameters
+  const tokens = await getTokens(client, parameters)
+  return tokens.find(getToken.predicate(addressOrSymbol))
+}
+
+export namespace getToken {
+  export type Parameters<
+    chain extends Chains.Chain | undefined = Chains.Chain | undefined,
+  > = getTokens.Parameters<chain> & {
+    addressOrSymbol: Token.Symbol | Address.Address
+  }
+
+  export type ReturnType = Token.Token | undefined
+
+  export function predicate(addressOrSymbol: Token.Symbol | Address.Address) {
+    return (token: Token.Token) => {
+      if (!addressOrSymbol) return false
+      if (Address.validate(addressOrSymbol))
+        return Address.isEqual(token.address, addressOrSymbol)
+      if (addressOrSymbol === 'native') return token.address === zeroAddress
+      return addressOrSymbol === token.symbol
+    }
+  }
+}
+
+/**
+ * Resolves the fee token to use. Resolves the provided address or symbol,
+ * or the defaults to the fee token stored in state.
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Fee token.
+ */
+export async function resolveFeeToken<chain extends Chains.Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters?: resolveFeeToken.Parameters<chain> | undefined,
+): Promise<resolveFeeToken.ReturnType> {
+  const { chain = client.chain, store } = parameters ?? {}
+  const state = (store?.getState() ?? {}) as State
+  const addressOrSymbol = parameters?.addressOrSymbol ?? state.feeToken
+
+  const feeTokens = await getTokens(client, { chain: chain! }).then((tokens) =>
+    tokens.filter((token) => token.feeToken),
+  )
+  const feeToken = feeTokens?.find((feeToken) => {
+    if (!addressOrSymbol) return false
+    if (addressOrSymbol === 'native' && feeToken.address === zeroAddress)
+      return true
+    if (
+      Address.validate(addressOrSymbol) &&
+      Address.isEqual(feeToken.address, addressOrSymbol)
+    )
+      return true
+    return addressOrSymbol === feeToken.symbol
+  })
+
+  return feeToken
+}
+
+export declare namespace resolveFeeToken {
+  export type Parameters<
+    chain extends Chains.Chain | undefined = Chains.Chain | undefined,
+  > = getTokens.Parameters<chain> & {
+    /**
+     * Fee token to resolve.
+     */
+    addressOrSymbol?: Token.Symbol | Address.Address | undefined
+    /**
+     * Porto store.
+     */
+    store?: Store<any> | undefined
+  }
+
+  export type ReturnType = Token.Token | undefined
+}