accounts 0.3.0 → 0.4.1

package/src/core/zod/request.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, test } from 'vp/test'
+
+import * as Schema from '../Schema.js'
+import * as RpcRequest from './request.js'
+
+describe('validate', () => {
+  test('default: validates eth_accounts', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'eth_accounts',
+    })
+    expect(result._decoded).toMatchInlineSnapshot(`
+      {
+        "method": "eth_accounts",
+      }
+    `)
+  })
+
+  test('default: validates eth_chainId', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'eth_chainId',
+    })
+    expect(result._decoded).toMatchInlineSnapshot(`
+      {
+        "method": "eth_chainId",
+      }
+    `)
+  })
+
+  test('default: validates wallet_connect without params', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'wallet_connect',
+    })
+    expect(result._decoded).toMatchInlineSnapshot(`
+      {
+        "method": "wallet_connect",
+      }
+    `)
+  })
+
+  test('default: validates wallet_connect with capabilities', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'wallet_connect',
+      params: [{ capabilities: { method: 'register' } }],
+    })
+    expect(result._decoded).toMatchInlineSnapshot(`
+      {
+        "method": "wallet_connect",
+        "params": [
+          {
+            "capabilities": {
+              "method": "register",
+            },
+          },
+        ],
+      }
+    `)
+  })
+
+  test('default: validates wallet_disconnect', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'wallet_disconnect',
+    })
+    expect(result._decoded).toMatchInlineSnapshot(`
+      {
+        "method": "wallet_disconnect",
+      }
+    `)
+  })
+
+  test('default: validates wallet_switchEthereumChain with hex chainId', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'wallet_switchEthereumChain',
+      params: [{ chainId: '0xa' }],
+    })
+    expect(result._decoded).toMatchInlineSnapshot(`
+      {
+        "method": "wallet_switchEthereumChain",
+        "params": [
+          {
+            "chainId": 10,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('behavior: preserves original request properties', () => {
+    const result = RpcRequest.validate(Schema.Request, {
+      method: 'eth_accounts',
+      id: 1,
+      jsonrpc: '2.0',
+    })
+    expect({ id: (result as any).id, jsonrpc: (result as any).jsonrpc }).toMatchInlineSnapshot(`
+      {
+        "id": 1,
+        "jsonrpc": "2.0",
+      }
+    `)
+  })
+
+  test('error: throws UnsupportedMethodError for unknown methods', () => {
+    expect(() =>
+      RpcRequest.validate(Schema.Request, {
+        method: 'eth_unknownMethod',
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Provider.UnsupportedMethodError: Unsupported method "eth_unknownMethod".]`,
+    )
+  })
+
+  test('error: throws ProviderRpcError for invalid params', () => {
+    expect(() =>
+      RpcRequest.validate(Schema.Request, {
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: 'not-hex' }],
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[ProviderRpcError: Invalid params: params.0.chainId: Expected hex value, params.0.chainId: Invalid input]`,
+    )
+  })
+})

package/src/core/zod/request.ts

@@ -0,0 +1,70 @@
+import { Provider } from 'ox'
+import * as z from 'zod/mini'
+
+/**
+ * Validates an incoming JSON-RPC request against the provider schema.
+ *
+ * Returns the original request augmented with a `_decoded` property
+ * containing the Zod-parsed output (with codec transforms applied).
+ *
+ * Throws EIP-1193 errors on validation failure:
+ * - `4200` if the method is not in the discriminated union
+ * - `-32602` if params fail validation
+ */
+export function validate<const schema extends z.ZodMiniType>(
+  schema: schema,
+  value: unknown,
+): WithDecoded<schema> {
+  const result = z.safeParse(schema, value)
+  if (result.error) {
+    const issue = result.error.issues.at(0)
+    if (issue?.code === 'invalid_union' && (issue as any).note === 'No matching discriminator')
+      throw new Provider.UnsupportedMethodError({
+        message: `Unsupported method "${(value as any)?.method}".`,
+      })
+    throw new Provider.ProviderRpcError(
+      -32602,
+      `Invalid params: ${formatIssues(result.error.issues)}`,
+    )
+  }
+  return { ...(value as any), _decoded: result.data } as never
+}
+
+function formatIssues(issues: readonly z.core.$ZodIssue[]): string {
+  return issues
+    .flatMap((issue) => {
+      if (issue.code === 'invalid_union' && issue.errors.length > 0)
+        return issue.errors.flatMap((branch) =>
+          branch.map(
+            (i) =>
+              `${[...issue.path, ...i.path].join('.')}: ${i.code === 'invalid_union' && i.errors.length > 0 ? formatIssues([i]) : i.message}`,
+          ),
+        )
+      return [`${issue.path.join('.')}: ${issue.message}`]
+    })
+    .join(', ')
+}
+
+/**
+ * A validated request with the decoded (Zod-parsed) output attached.
+ *
+ * Distributes over the union so that switching on `method` narrows
+ * both the input and `_decoded` properties together.
+ */
+export type WithDecoded<schema extends z.ZodMiniType> =
+  z.output<schema> extends infer decoded
+    ? decoded extends { method: infer m extends string }
+      ? Extract<z.input<schema>, { method: m }> & { _decoded: decoded }
+      : never
+    : never
+
+/**
+ * Encodes a decoded (output) value back to its wire (input) format
+ * by running codec `reverseTransform` functions.
+ */
+export function encode<const schema extends z.ZodMiniType>(
+  schema: schema,
+  value: z.output<schema>,
+): z.input<schema> {
+  return (z as never as { encode: typeof encode }).encode(schema, value)
+}

package/src/core/zod/rpc.ts

@@ -0,0 +1,374 @@
+import type { SignatureEnvelope } from 'ox/tempo'
+import * as z from 'zod/mini'
+
+import * as Schema from '../Schema.js'
+import * as u from './utils.js'
+
+export const log = z.object({
+  address: u.address(),
+  blockHash: u.hex(),
+  blockNumber: u.bigint(),
+  data: u.hex(),
+  logIndex: u.number(),
+  removed: z.boolean(),
+  topics: z.readonly(z.array(u.hex())),
+  transactionHash: u.hex(),
+  transactionIndex: u.number(),
+})
+
+export const receipt = z.object({
+  blobGasPrice: z.optional(u.bigint()),
+  blobGasUsed: z.optional(u.bigint()),
+  blockHash: u.hex(),
+  blockNumber: u.bigint(),
+  contractAddress: z.nullable(u.address()),
+  cumulativeGasUsed: u.bigint(),
+  effectiveGasPrice: u.bigint(),
+  feePayer: z.optional(u.address()),
+  feeToken: z.optional(u.address()),
+  from: u.address(),
+  gasUsed: u.bigint(),
+  logs: z.array(log),
+  logsBloom: u.hex(),
+  root: z.optional(u.hex()),
+  status: z.codec(u.hex(), z.enum(['success', 'reverted']), {
+    decode: (value) => (value === '0x1' ? 'success' : 'reverted'),
+    encode: (value) => (value === 'success' ? '0x1' : '0x0'),
+  }),
+  to: z.nullable(u.address()),
+  transactionHash: u.hex(),
+  transactionIndex: u.number(),
+  type: u.hex(),
+})
+
+export const signatureEnvelope = z.custom<SignatureEnvelope.SignatureEnvelopeRpc>()
+
+export const keyType = z.union([z.literal('secp256k1'), z.literal('p256'), z.literal('webAuthn')])
+
+export const keyAuthorization = z.object({
+  address: u.address(),
+  chainId: u.bigint(),
+  expiry: z.nullish(u.number()),
+  keyId: u.address(),
+  keyType,
+  limits: z.optional(z.readonly(z.array(z.object({ token: u.address(), limit: u.bigint() })))),
+  signature: signatureEnvelope,
+})
+
+export const call = z.object({
+  data: z.optional(u.hex()),
+  to: z.optional(u.address()),
+  value: z.optional(u.bigint()),
+})
+
+export const transactionRequest = z.object({
+  accessList: z.optional(
+    z.array(z.object({ address: u.address(), storageKeys: z.array(u.hex()) })),
+  ),
+  calls: z.optional(z.readonly(z.array(call))),
+  chainId: z.optional(u.number()),
+  feePayer: z.optional(z.union([z.boolean(), z.url()])),
+  feeToken: z.optional(u.address()),
+  from: z.optional(u.address()),
+  gas: z.optional(u.bigint()),
+  maxFeePerGas: z.optional(u.bigint()),
+  maxPriorityFeePerGas: z.optional(u.bigint()),
+  nonce: z.optional(u.number()),
+  nonceKey: z.optional(u.bigint()),
+  validAfter: z.optional(u.number()),
+  validBefore: z.optional(u.number()),
+  value: z.optional(u.bigint()),
+})
+
+export namespace eth_accounts {
+  export const schema = Schema.defineItem({
+    method: z.literal('eth_accounts'),
+    params: undefined,
+    returns: z.readonly(z.array(u.address())),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace eth_chainId {
+  export const schema = Schema.defineItem({
+    method: z.literal('eth_chainId'),
+    params: undefined,
+    returns: u.hex(),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace eth_requestAccounts {
+  export const schema = Schema.defineItem({
+    method: z.literal('eth_requestAccounts'),
+    params: undefined,
+    returns: z.readonly(z.array(u.address())),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace eth_sendTransaction {
+  export const schema = Schema.defineItem({
+    method: z.literal('eth_sendTransaction'),
+    params: z.readonly(z.tuple([transactionRequest])),
+    returns: u.hex(),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace eth_signTransaction {
+  export const schema = Schema.defineItem({
+    method: z.literal('eth_signTransaction'),
+    params: z.readonly(z.tuple([transactionRequest])),
+    returns: u.hex(),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace eth_sendTransactionSync {
+  export const schema = Schema.defineItem({
+    method: z.literal('eth_sendTransactionSync'),
+    params: z.readonly(z.tuple([transactionRequest])),
+    returns: receipt,
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace eth_signTypedData_v4 {
+  export const schema = Schema.defineItem({
+    method: z.literal('eth_signTypedData_v4'),
+    params: z.readonly(z.tuple([u.address(), z.string()])),
+    returns: u.hex(),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace personal_sign {
+  export const schema = Schema.defineItem({
+    method: z.literal('personal_sign'),
+    params: z.readonly(z.tuple([u.hex(), u.address()])),
+    returns: u.hex(),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+const sendCallsCapabilities = z.optional(z.object({ sync: z.optional(z.boolean()) }))
+
+export namespace wallet_sendCalls {
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_sendCalls'),
+    params: z.optional(
+      z.readonly(
+        z.tuple([
+          z.object({
+            atomicRequired: z.optional(z.boolean()),
+            calls: z.readonly(z.array(call)),
+            capabilities: sendCallsCapabilities,
+            chainId: z.optional(u.number()),
+            from: z.optional(u.address()),
+            version: z.optional(z.string()),
+          }),
+        ]),
+      ),
+    ),
+    returns: z.object({
+      atomic: z.optional(z.boolean()),
+      capabilities: sendCallsCapabilities,
+      chainId: z.optional(u.number()),
+      id: z.string(),
+      receipts: z.optional(z.array(receipt)),
+      status: z.optional(z.number()),
+      version: z.optional(z.string()),
+    }),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_getBalances {
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_getBalances'),
+    params: z.optional(
+      z.readonly(
+        z.tuple([
+          z.object({
+            account: z.optional(u.address()),
+            chainId: z.optional(u.number()),
+            tokens: z.optional(z.readonly(z.array(u.address()))),
+          }),
+        ]),
+      ),
+    ),
+    returns: z.readonly(
+      z.array(
+        z.object({
+          address: u.address(),
+          balance: u.bigint(),
+          decimals: z.number(),
+          display: z.string(),
+          name: z.string(),
+          symbol: z.string(),
+        }),
+      ),
+    ),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_getCapabilities {
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_getCapabilities'),
+    params: z.optional(
+      z.readonly(
+        z.union([z.tuple([u.address()]), z.tuple([u.address(), z.readonly(z.array(u.hex()))])]),
+      ),
+    ),
+    returns: z.record(
+      u.hex(),
+      z.object({
+        accessKeys: z.optional(
+          z.object({
+            status: z.union([z.literal('supported'), z.literal('unsupported')]),
+          }),
+        ),
+        atomic: z.object({
+          status: z.union([z.literal('supported'), z.literal('ready'), z.literal('unsupported')]),
+        }),
+      }),
+    ),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_authorizeAccessKey {
+  export const parameters = z.object({
+    address: z.optional(u.address()),
+    expiry: z.number(),
+    keyType: z.optional(keyType),
+    limits: z.optional(z.readonly(z.array(z.object({ token: u.address(), limit: u.bigint() })))),
+    publicKey: z.optional(u.hex()),
+  })
+
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_authorizeAccessKey'),
+    params: z.readonly(z.tuple([parameters])),
+    returns: keyAuthorization,
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_revokeAccessKey {
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_revokeAccessKey'),
+    params: z.readonly(
+      z.tuple([z.object({ address: u.address(), accessKeyAddress: u.address() })]),
+    ),
+    returns: undefined,
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_connect {
+  export const authorizeAccessKey = z.optional(wallet_authorizeAccessKey.parameters)
+
+  export const capabilities = {
+    request: z.optional(
+      z.union([
+        z.object({
+          digest: z.optional(u.hex()),
+          authorizeAccessKey,
+          method: z.literal('register'),
+          name: z.optional(z.string()),
+          userId: z.optional(z.string()),
+        }),
+        z.object({
+          digest: z.optional(u.hex()),
+          credentialId: z.optional(z.string()),
+          authorizeAccessKey,
+          method: z.optional(z.literal('login')),
+          selectAccount: z.optional(z.boolean()),
+        }),
+      ]),
+    ),
+    result: z.object({
+      keyAuthorization: z.optional(keyAuthorization),
+      signature: z.optional(u.hex()),
+    }),
+  }
+
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_connect'),
+    params: z.optional(
+      z.readonly(
+        z.tuple([
+          z.object({
+            capabilities: capabilities.request,
+            chainId: z.optional(u.number()),
+            version: z.optional(z.string()),
+          }),
+        ]),
+      ),
+    ),
+    returns: z.object({
+      accounts: z.readonly(
+        z.array(
+          z.object({
+            address: u.address(),
+            capabilities: capabilities.result,
+          }),
+        ),
+      ),
+    }),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_disconnect {
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_disconnect'),
+    params: undefined,
+    returns: undefined,
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_getCallsStatus {
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_getCallsStatus'),
+    params: z.optional(z.readonly(z.tuple([z.string()]))),
+    returns: z.object({
+      atomic: z.boolean(),
+      chainId: u.number(),
+      id: z.string(),
+      receipts: z.optional(z.array(receipt)),
+      status: z.number(),
+      version: z.string(),
+    }),
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}
+
+export namespace wallet_switchEthereumChain {
+  export const schema = Schema.defineItem({
+    method: z.literal('wallet_switchEthereumChain'),
+    params: z.readonly(z.tuple([z.object({ chainId: u.number() })])),
+    returns: undefined,
+  })
+  export type Encoded = Schema.Encoded<typeof schema>
+  export type Decoded = Schema.Decoded<typeof schema>
+}

package/src/core/zod/utils.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'vp/test'
+import * as z from 'zod/mini'
+
+import * as u from './utils.js'
+
+describe('address', () => {
+  test('default: accepts valid address', () => {
+    const schema = u.address()
+    expect(z.parse(schema, '0x0000000000000000000000000000000000000001')).toMatchInlineSnapshot(
+      `"0x0000000000000000000000000000000000000001"`,
+    )
+  })
+
+  test('error: rejects non-0x string', () => {
+    const schema = u.address()
+    expect(() => z.parse(schema, 'not-an-address')).toThrow()
+  })
+
+  test('error: rejects non-string', () => {
+    const schema = u.address()
+    expect(() => z.parse(schema, 123)).toThrow()
+  })
+})
+
+describe('hex', () => {
+  test('default: accepts valid hex', () => {
+    const schema = u.hex()
+    expect(z.parse(schema, '0xdeadbeef')).toMatchInlineSnapshot(`"0xdeadbeef"`)
+  })
+
+  test('error: rejects non-0x string', () => {
+    const schema = u.hex()
+    expect(() => z.parse(schema, 'deadbeef')).toThrow()
+  })
+})
+
+describe('number', () => {
+  test('default: decodes hex to number', () => {
+    const schema = u.number()
+    expect(z.parse(schema, '0xa')).toMatchInlineSnapshot(`10`)
+  })
+
+  test('default: decodes 0x0', () => {
+    const schema = u.number()
+    expect(z.parse(schema, '0x0')).toMatchInlineSnapshot(`0`)
+  })
+
+  test('error: rejects non-hex', () => {
+    const schema = u.number()
+    expect(() => z.parse(schema, 'not-hex')).toThrow()
+  })
+})
+
+describe('bigint', () => {
+  test('default: decodes hex to bigint', () => {
+    const schema = u.bigint()
+    expect(z.parse(schema, '0xff')).toMatchInlineSnapshot(`255n`)
+  })
+
+  test('default: decodes large value', () => {
+    const schema = u.bigint()
+    expect(z.parse(schema, '0xde0b6b3a7640000')).toMatchInlineSnapshot(`1000000000000000000n`)
+  })
+
+  test('error: rejects non-hex', () => {
+    const schema = u.bigint()
+    expect(() => z.parse(schema, 'not-hex')).toThrow()
+  })
+})

package/src/core/zod/utils.ts

@@ -0,0 +1,40 @@
+import { Hex } from 'ox'
+import * as z from 'zod/mini'
+import type * as zc from 'zod/v4/core'
+
+import type { OneOf } from '../../internal/types.js'
+
+/** EVM address (`0x...`). */
+export const address = () => z.templateLiteral(['0x', z.string()], 'Expected address')
+
+/** Hex-encoded bigint. Decodes from `0x...` hex or raw `bigint` to `bigint`. */
+export const bigint = () =>
+  z.codec(z.union([hex(), z.bigint()]) as never as ReturnType<typeof hex>, z.bigint(), {
+    decode: (value) =>
+      typeof value === 'bigint' ? value : value === '0x' ? 0n : Hex.toBigInt(value),
+    encode: (value) => Hex.fromNumber(value),
+  })
+
+/** Hex-encoded string (`0x...`). */
+export const hex = () => z.templateLiteral(['0x', z.string()], 'Expected hex value')
+
+/** Hex-encoded number. Decodes from `0x...` hex or raw `number` to `number`. */
+export const number = () =>
+  z.codec(z.union([hex(), z.number()]) as never as ReturnType<typeof hex>, z.number(), {
+    decode: (value) =>
+      typeof value === 'number' ? value : value === '0x' ? 0 : Hex.toNumber(value),
+    encode: (value) => Hex.fromNumber(value),
+  })
+
+/** `z.union` that narrows the output type so only one branch is active at a time. */
+export function oneOf<const type extends readonly zc.SomeType[]>(
+  options: type,
+): Omit<z.ZodMiniUnion<type>, '_zod'> & {
+  _zod: Omit<z.ZodMiniUnion<type>['_zod'], 'output'> & {
+    output: z.ZodMiniUnion<type>['_zod']['output'] extends object
+      ? OneOf<z.ZodMiniUnion<type>['_zod']['output']>
+      : z.ZodMiniUnion<type>['_zod']['output']
+  }
+} {
+  return z.union(options) as never
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export * as Ceremony from './core/Ceremony.js'
+export * as Dialog from './core/Dialog.js'
+export * as Messenger from './core/Messenger.js'
+export * as Schema from './core/Schema.js'
+export * as Provider from './core/Provider.js'
+export * as Expiry from './core/Expiry.js'
+export * as Remote from './core/Remote.js'
+export * as Rpc from './core/zod/rpc.js'
+export * as Store from './core/Store.js'
+export * as Storage from './core/Storage.js'
+export { dialog, dialog as tempoWallet } from './core/adapters/dialog.js'
+export { local } from './core/adapters/local.js'
+export { webAuthn } from './core/adapters/webAuthn.js'
+export { dangerous_secp256k1 } from './core/adapters/dangerous_secp256k1.js'