mppx 0.0.1 → 0.1.0

package/src/tempo/stream/index.ts

@@ -0,0 +1,7 @@
+export * as Chain from './Chain.js'
+export * as Channel from './Channel.js'
+export * as ChannelStore from './ChannelStore.js'
+export * as Receipt from './Receipt.js'
+export * as Sse from './Sse.js'
+export * as Types from './Types.js'
+export * as Voucher from './Voucher.js'

package/src/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "types": ["node"]
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["./**/*.test.ts", "./**/*.test-d.ts"]
+}

package/src/viem/Account.test.ts

@@ -0,0 +1,71 @@
+import { createClient, http } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { mainnet } from 'viem/chains'
+import { describe, expect, test } from 'vitest'
+import * as Account from './Account.js'
+
+const account = privateKeyToAccount(
+  '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+)
+
+const otherAccount = privateKeyToAccount(
+  '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+)
+
+const clientWithAccount = createClient({
+  account,
+  chain: mainnet,
+  transport: http(),
+})
+
+const clientWithoutAccount = createClient({
+  chain: mainnet,
+  transport: http(),
+})
+
+describe('getResolver', () => {
+  test('behavior: returns Account when passed as default', () => {
+    const getAccount = Account.getResolver({ account })
+    const result = getAccount(clientWithoutAccount)
+    expect(result).toBe(account)
+  })
+
+  test('behavior: returns Account when passed as override', () => {
+    const getAccount = Account.getResolver()
+    const result = getAccount(clientWithoutAccount, { account: otherAccount })
+    expect(result).toBe(otherAccount)
+  })
+
+  test('behavior: override takes precedence over default', () => {
+    const getAccount = Account.getResolver({ account })
+    const result = getAccount(clientWithoutAccount, { account: otherAccount })
+    expect(result).toBe(otherAccount)
+  })
+
+  test('behavior: falls back to client.account when no account provided', () => {
+    const getAccount = Account.getResolver()
+    const result = getAccount(clientWithAccount)
+    expect(result).toBe(account)
+  })
+
+  test('behavior: Address returns parsed account', () => {
+    const getAccount = Account.getResolver()
+    const result = getAccount(clientWithoutAccount, { account: account.address })
+    expect(result.address).toBe(account.address)
+    expect(result.type).toBe('json-rpc')
+  })
+
+  test('behavior: Address as default returns parsed account', () => {
+    const getAccount = Account.getResolver({ account: account.address })
+    const result = getAccount(clientWithoutAccount)
+    expect(result.address).toBe(account.address)
+    expect(result.type).toBe('json-rpc')
+  })
+
+  test('error: throws when no account and client has no account', () => {
+    const getAccount = Account.getResolver()
+    expect(() => getAccount(clientWithoutAccount)).toThrowErrorMatchingInlineSnapshot(
+      `[Error: No \`account\` provided. Pass \`account\` to parameters or context.]`,
+    )
+  })
+})

package/src/viem/Account.ts

@@ -0,0 +1,30 @@
+import type { Address, Client, Account as viem_Account } from 'viem'
+import { parseAccount } from 'viem/accounts'
+
+export type Account = viem_Account
+
+export function getResolver(parameters: getResolver.Parameters = {}) {
+  const { account: defaultAccount } = parameters
+
+  return (
+    client: Client,
+    { account: override }: { account?: Account | Address | undefined } = {},
+  ): Account => {
+    const account = override ?? defaultAccount
+
+    if (!account) {
+      if (!client.account)
+        throw new Error('No `account` provided. Pass `account` to parameters or context.')
+      return client.account
+    }
+
+    return parseAccount(account)
+  }
+}
+
+export declare namespace getResolver {
+  type Parameters = {
+    /** Account to use for signing. If an Address is provided, it must match the client's account. */
+    account?: Account | Address | undefined
+  }
+}

package/src/viem/Client.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'vitest'
+import * as Client from './Client.js'
+
+const rpcUrl = { 42: 'https://rpc.example.com', 99: 'https://rpc2.example.com' } as const
+
+describe('getResolver', () => {
+  test('behavior: creates client from rpcUrl for given chainId', async () => {
+    const getClient = Client.getResolver({
+      rpcUrl,
+    })
+
+    const client = await getClient({ chainId: 42 })
+
+    expect(client).toBeDefined()
+    expect(client.chain?.id).toBe(42)
+  })
+
+  test('behavior: falls back to first rpcUrl key when chainId is 0', async () => {
+    const getClient = Client.getResolver({
+      rpcUrl,
+    })
+
+    const client = await getClient({})
+
+    expect(client.chain?.id).toBe(42)
+  })
+
+  test('behavior: spreads chain into created client', async () => {
+    const chain = { id: 1, name: 'test' }
+    const getClient = Client.getResolver({
+      chain: chain as never,
+      rpcUrl,
+    })
+
+    const client = await getClient({ chainId: 99 })
+
+    expect(client.chain?.id).toBe(99)
+    expect(client.chain?.name).toBe('test')
+  })
+
+  test('error: throws when no rpcUrl provided', () => {
+    const getClient = Client.getResolver({})
+
+    expect(() => getClient({ chainId: 1 })).toThrowErrorMatchingInlineSnapshot(
+      `[Error: No \`rpcUrl\` provided.]`,
+    )
+  })
+
+  test('error: throws when chainId not found in rpcUrl', () => {
+    const getClient = Client.getResolver({
+      rpcUrl: { 42: 'https://example.com' },
+    })
+
+    expect(() => getClient({ chainId: 99 })).toThrowErrorMatchingInlineSnapshot(
+      `[Error: No \`rpcUrl\` configured for \`chainId\` (99).]`,
+    )
+  })
+})

package/src/viem/Client.ts

@@ -0,0 +1,33 @@
+import { type Chain, type Client, createClient, http } from 'viem'
+import type { MaybePromise } from '../internal/types.js'
+
+export function getResolver(
+  parameters: getResolver.Parameters & {
+    /** Default chain to use if not provided. */
+    chain?: Chain | undefined
+    /** RPC URLs keyed by chain ID. */
+    rpcUrl?: ({ [chainId: number]: string } & object) | undefined
+  },
+): (parameters: { chainId?: number | undefined }) => MaybePromise<Client> {
+  const { chain, getClient, rpcUrl } = parameters
+
+  if (getClient) return getClient
+
+  return ({ chainId }: { chainId?: number | undefined }) => {
+    if (!rpcUrl) throw new Error('No `rpcUrl` provided.')
+    const resolvedChainId = chainId || Number(Object.keys(rpcUrl)[0])!
+    const url = rpcUrl[resolvedChainId as keyof typeof rpcUrl]
+    if (!url) throw new Error(`No \`rpcUrl\` configured for \`chainId\` (${resolvedChainId}).`)
+    return createClient({
+      chain: { ...chain, id: resolvedChainId } as never,
+      transport: http(url),
+    })
+  }
+}
+
+export declare namespace getResolver {
+  type Parameters = {
+    /** Function that returns a client for the given chain ID. */
+    getClient?: ((parameters: { chainId?: number | undefined }) => MaybePromise<Client>) | undefined
+  }
+}

package/src/zod.ts

@@ -0,0 +1,47 @@
+import { type ZodMiniOptional, type ZodMiniType, z } from 'zod/mini'
+
+export * from 'zod/mini'
+
+/** Numeric string amount (e.g., "1", "1.5", "1000000"). */
+export function amount() {
+  return z.string().check(z.regex(/^\d+(\.\d+)?$/, 'Invalid amount'))
+}
+
+/** ISO 8601 datetime string (e.g., "2025-01-06T12:00:00Z"). */
+export function datetime() {
+  return z
+    .string()
+    .check(
+      z.regex(
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
+        'Invalid ISO 8601 datetime',
+      ),
+    )
+}
+
+/** Hex-encoded address string (0x-prefixed, 40 hex chars). */
+export function address() {
+  return z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/, 'Invalid address'))
+}
+
+/** Hex-encoded hash string (0x-prefixed, 64 hex chars). */
+export function hash() {
+  return z.string().check(z.regex(/^0x[0-9a-fA-F]{64}$/, 'Invalid hash'))
+}
+
+/** Billing period: "day", "week", "month", "year", or seconds as string. */
+export function period() {
+  return z.string().check(z.regex(/^(day|week|month|year|\d+)$/, 'Invalid period'))
+}
+
+/** Hex-encoded signature string (0x-prefixed). */
+export function signature() {
+  return z.string().check(z.regex(/^0x[0-9a-fA-F]+$/, 'Invalid signature'))
+}
+
+/** Checks if a schema is optional and returns the inner type if so. */
+export function unwrapOptional<schema extends ZodMiniType>(schema: schema): ZodMiniType {
+  if (schema._zod.def.type === 'optional')
+    return (schema as unknown as ZodMiniOptional)._zod.def.innerType as ZodMiniType
+  return schema
+}