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

package/src/core/internal/relay/schema/token.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod/mini'
+import * as u from '../../schema/utils.js'
+
+export const Token = z.object({
+  address: u.address(),
+  decimals: z.number(),
+  feeToken: z.optional(z.boolean()),
+  interop: z.optional(z.boolean()),
+  nativeRate: z.optional(u.bigint()),
+  symbol: z.string(),
+  uid: z.string(),
+})
+export type Token = z.infer<typeof Token>
+
+export const Symbol = z.string().check(z.regex(/^[A-Z0-9]+$/))
+export type Symbol = z.infer<typeof Symbol>

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

@@ -0,0 +1,141 @@
+import { describe, expect, test } from 'vitest'
+import * as Anvil from '../../../test/src/anvil.js'
+import * as TestConfig from '../../../test/src/config.js'
+import * as RequiredFunds from './requiredFunds.js'
+import * as Tokens from './tokens.js'
+
+const porto = TestConfig.getPorto()
+const client = TestConfig.getRelayClient(porto)
+const tokens = await Tokens.getTokens(client)
+
+// TODO: unskip when interop supported
+describe.skip('toRelay', () => {
+  test('param: empty requiredFunds array', async () => {
+    const result = RequiredFunds.toRelay([], { tokens })
+
+    expect(result).toMatchInlineSnapshot('[]')
+  })
+
+  test('behavior: with address - returns unchanged', async () => {
+    const result = RequiredFunds.toRelay(
+      [
+        {
+          address: '0x1234567890123456789012345678901234567890' as const,
+          value: 1000000000000000000n,
+        },
+      ],
+      { tokens },
+    )
+
+    expect(result.map((x) => x.value)).toMatchInlineSnapshot(`
+      [
+        1000000000000000000n,
+      ]
+    `)
+  })
+
+  test('behavior: with symbol - converts to address and value', async () => {
+    const result = RequiredFunds.toRelay(
+      [
+        {
+          symbol: 'EXP',
+          value: '1.5',
+        },
+      ],
+      { tokens },
+    )
+
+    expect(result[0]!.address).toBeDefined()
+    expect(result[0]!.value).toMatchInlineSnapshot('1500000000000000000n')
+  })
+
+  test('behavior: with integer value string', async () => {
+    const result = RequiredFunds.toRelay(
+      [
+        {
+          symbol: 'EXP',
+          value: '2',
+        },
+      ],
+      { tokens },
+    )
+
+    expect(result[0]!.address).toBeDefined()
+    expect(result[0]!.value).toMatchInlineSnapshot('2000000000000000000n')
+  })
+
+  test('behavior: mixed address and symbol entries', async () => {
+    const result = RequiredFunds.toRelay(
+      [
+        {
+          address: '0x1234567890123456789012345678901234567890',
+          value: 1000000000000000000n,
+        },
+        {
+          symbol: 'EXP',
+          value: '0.5',
+        },
+      ],
+      { tokens },
+    )
+
+    expect(result[0]!.address).toBeDefined()
+    expect(result[0]!.value).toMatchInlineSnapshot('1000000000000000000n')
+    expect(result[1]!.address).toBeDefined()
+    expect(result[1]!.value).toMatchInlineSnapshot('500000000000000000n')
+  })
+
+  test('behavior: only non-interop tokens available', async () => {
+    try {
+      RequiredFunds.toRelay(
+        [
+          {
+            symbol: Anvil.enabled ? 'ETH' : 'USDT',
+            value: '1.0',
+          },
+        ],
+        { tokens },
+      )
+    } catch (error) {
+      expect((error as Error).message).toMatch(
+        /interop token not found: (ETH|USDT)/,
+      )
+    }
+  })
+
+  test('error: symbol not found in interop tokens', async () => {
+    expect(() =>
+      RequiredFunds.toRelay(
+        [
+          {
+            symbol: 'UNKNOWN',
+            value: '1.0',
+          },
+        ],
+        { tokens },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '[Error: interop token not found: UNKNOWN]',
+    )
+  })
+
+  test('error: non-existent symbol with existing addresses', async () => {
+    expect(() =>
+      RequiredFunds.toRelay(
+        [
+          {
+            address: '0x1234567890123456789012345678901234567890',
+            value: 1000000000000000000n,
+          },
+          {
+            symbol: 'NONEXISTENT',
+            value: '1.0',
+          },
+        ],
+        { tokens },
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '[Error: interop token not found: NONEXISTENT]',
+    )
+  })
+})

package/src/core/internal/requiredFunds.ts

@@ -0,0 +1,45 @@
+import * as Value from 'ox/Value'
+import type * as Capabilities_relay from './relay/schema/capabilities.js'
+import type * as Capabilities from './schema/capabilities.js'
+import type * as Token from './schema/token.js'
+
+/**
+ * Transforms into Relay-formatted required funds.
+ *
+ * @param requiredFunds - The required funds object to convert.
+ * @param options - The options for the conversion.
+ * @returns The converted required funds object.
+ */
+// TODO: perhaps Relay should support `Capabilities.requiredFunds.Request` format.
+export function toRelay(
+  requiredFunds: toRelay.Value,
+  options: toRelay.Options,
+): toRelay.ReturnType {
+  const { tokens } = options
+
+  const interopTokens = tokens.filter((token) => token.interop)
+
+  return requiredFunds.map((requiredFund) => {
+    if (requiredFund.address) return requiredFund
+
+    const interopToken = interopTokens.find(
+      (token) => token.symbol === requiredFund.symbol,
+    )
+    if (!interopToken)
+      throw new Error(`interop token not found: ${requiredFund.symbol}`)
+
+    return {
+      address: interopToken.address,
+      value: Value.from(requiredFund.value, interopToken.decimals),
+    }
+  })
+}
+
+export namespace toRelay {
+  export type Value = Capabilities.requiredFunds.Request
+
+  export type Options = {
+    tokens: readonly Token.Token[]
+  }
+  export type ReturnType = Capabilities_relay.requiredFunds.Request
+}