mppx 0.8.17 → 0.8.18

package/src/tempo/client/index.ts

@@ -1,17 +0,0 @@
-export { charge } from './Charge.js'
-export { session, tempo } from './Methods.js'
-export { session as sessionLegacy } from '../legacy/client/index.js'
-export { subscription } from './Subscription.js'
-export type {
-  PaymentResponse as SessionLegacyPaymentResponse,
-  SessionManager as SessionLegacyManager,
-} from '../legacy/client/index.js'
-export { sessionManager as sessionLegacyManager } from '../legacy/client/index.js'
-export { session as sessionMethod } from '../session/client/Session.js'
-export type {
-  PaymentResponse,
-  SessionManager,
-  SessionManagerSseOptions,
-  SessionManagerWebSocketOptions,
-} from '../session/client/SessionManager.js'
-export { sessionManager } from '../session/client/SessionManager.js'

package/src/tempo/index.ts

@@ -1,5 +0,0 @@
-export * as Proof from './Proof.js'
-export * as Methods from './Methods.js'
-export * as Session from './session/index.js'
-export * as SessionLegacy from './legacy/index.js'
-export * as Subscription from './subscription/index.js'

package/src/tempo/internal/account.ts

@@ -1,56 +0,0 @@
-import type { Account, Address } from 'viem'
-import type { Account as TempoAccount } from 'viem/tempo'
-
-/** Returns whether an account is a Tempo access-key account. */
-export function isAccessKeyAccount(
-  account: Account,
-): account is Account & TempoAccount.AccessKeyAccount {
-  return 'accessKeyAddress' in account
-}
-
-/** Returns the address that should authorize direct account signatures. */
-export function getAccountSignerAddress(account: Account): Address {
-  return isAccessKeyAccount(account) ? account.accessKeyAddress : account.address
-}
-
-/**
- * Resolves a recipient address and optional fee payer from flexible input parameters.
- *
- * Accepts either `account` or `recipient` as the parameter name. When the value
- * is an `Account`, its address is extracted. If `feePayer` is `true`, the
- * account also acts as the fee payer. Alternatively, a separate `Account`
- * can be provided as the fee payer, or a URL string pointing to a fee payer
- * relay service (used with `withFeePayer` transport wrapping).
- *
- * @returns An object with `account`, `feePayer`, `feePayerUrl`, and `recipient`.
- */
-export function resolve(parameters: resolve.Parameters) {
-  const account = (() => {
-    if (typeof parameters.account === 'object') return parameters.account
-    return undefined
-  })()
-  const recipient = (() => {
-    if (parameters.recipient) return parameters.recipient
-    if (typeof parameters.account === 'object') return parameters.account.address
-    return parameters.account
-  })()
-  const feePayerUrl = typeof parameters.feePayer === 'string' ? parameters.feePayer : undefined
-  const feePayer = (() => {
-    if (typeof parameters.feePayer === 'string') return undefined
-    if (typeof parameters.account === 'object' && parameters.feePayer === true)
-      return parameters.account
-    if (typeof parameters.feePayer === 'object') return parameters.feePayer
-    return undefined
-  })()
-  return { account, feePayer, feePayerUrl, recipient: recipient as Address | undefined }
-}
-
-export declare namespace resolve {
-  type Parameters = {
-    recipient?: Address | undefined
-    /** Account or address that performs payment operations / receives payment. */
-    account?: Account | Address | undefined
-    /** When `true`, the account also sponsors fees. An `Account` object or URL string can also be provided as a dedicated fee payer. */
-    feePayer?: Account | string | true | undefined
-  }
-}

package/src/tempo/internal/address.test.ts

@@ -1,42 +0,0 @@
-import { TempoAddress } from 'ox/tempo'
-import { describe, expect, test } from 'vp/test'
-
-import { isEqual } from './address.js'
-
-const address = '0x742d35Cc6634C0532925a3b844Bc9e7595F2bD28'
-const otherAddress = '0x52908400098527886E0F7030069857D2E4169EE7'
-
-describe('isEqual', () => {
-  const representations = [
-    { name: 'mixed-case hex', value: address },
-    { name: 'lowercase hex', value: address.toLowerCase() as `0x${string}` },
-    { name: 'Tempo-formatted', value: TempoAddress.format(address) },
-  ] as const
-
-  const otherRepresentations = [
-    { name: 'mixed-case hex', value: otherAddress },
-    { name: 'lowercase hex', value: otherAddress.toLowerCase() as `0x${string}` },
-    { name: 'Tempo-formatted', value: TempoAddress.format(otherAddress) },
-  ] as const
-
-  test.each([
-    ...representations.flatMap((a) =>
-      representations.map((b) => ({
-        a: a.value,
-        b: b.value,
-        expected: true,
-        name: `${a.name} and ${b.name} representations of the same address`,
-      })),
-    ),
-    ...representations.flatMap((a) =>
-      otherRepresentations.map((b) => ({
-        a: a.value,
-        b: b.value,
-        expected: false,
-        name: `${a.name} and ${b.name} representations of different addresses`,
-      })),
-    ),
-  ])('$name', ({ a, b, expected }) => {
-    expect(isEqual(a, b)).toBe(expected)
-  })
-})

package/src/tempo/internal/address.ts

@@ -1,6 +0,0 @@
-import { TempoAddress } from 'ox/tempo'
-
-/** Returns whether two hex or Tempo-formatted addresses resolve to the same address. */
-export function isEqual(a: TempoAddress.Address, b: TempoAddress.Address) {
-  return TempoAddress.resolve(a).toLowerCase() === TempoAddress.resolve(b).toLowerCase()
-}

package/src/tempo/internal/auto-swap.test.ts

@@ -1,198 +0,0 @@
-import type { Address } from 'viem'
-import { describe, expect, test, vi } from 'vp/test'
-
-import { defaultCurrencies, InsufficientFundsError, resolve } from './auto-swap.js'
-
-describe('defaultCurrencies', () => {
-  test('default', () => {
-    expect(defaultCurrencies).toMatchInlineSnapshot(`
-      [
-        "0x20c0000000000000000000000000000000000000",
-        "0x20C000000000000000000000b9537d11c60E8b50",
-      ]
-    `)
-  })
-})
-
-describe('resolve', () => {
-  const defaults = defaultCurrencies
-
-  test('returns false for undefined', () => {
-    expect(resolve(undefined, defaults)).toMatchInlineSnapshot(`false`)
-  })
-
-  test('returns false for false', () => {
-    expect(resolve(false, defaults)).toMatchInlineSnapshot(`false`)
-  })
-
-  test('true resolves to defaults with 1% slippage', () => {
-    expect(resolve(true, defaults)).toMatchInlineSnapshot(`
-      {
-        "slippage": 1,
-        "tokenIn": [
-          "0x20c0000000000000000000000000000000000000",
-          "0x20C000000000000000000000b9537d11c60E8b50",
-        ],
-      }
-    `)
-  })
-
-  test('empty options resolves to defaults with 1% slippage', () => {
-    expect(resolve({}, defaults)).toMatchInlineSnapshot(`
-      {
-        "slippage": 1,
-        "tokenIn": [
-          "0x20c0000000000000000000000000000000000000",
-          "0x20C000000000000000000000b9537d11c60E8b50",
-        ],
-      }
-    `)
-  })
-
-  test('custom slippage', () => {
-    expect(resolve({ slippage: 5 }, defaults)).toMatchInlineSnapshot(`
-      {
-        "slippage": 5,
-        "tokenIn": [
-          "0x20c0000000000000000000000000000000000000",
-          "0x20C000000000000000000000b9537d11c60E8b50",
-        ],
-      }
-    `)
-  })
-
-  test('custom tokenIn prepends to defaults', () => {
-    const custom = '0x0000000000000000000000000000000000000099' as Address
-    expect(resolve({ tokenIn: [custom] }, defaults)).toMatchInlineSnapshot(`
-      {
-        "slippage": 1,
-        "tokenIn": [
-          "0x0000000000000000000000000000000000000099",
-          "0x20c0000000000000000000000000000000000000",
-          "0x20C000000000000000000000b9537d11c60E8b50",
-        ],
-      }
-    `)
-  })
-
-  test('custom tokenIn deduplicates against defaults', () => {
-    expect(resolve({ tokenIn: [defaults[0]!] }, defaults)).toMatchInlineSnapshot(`
-      {
-        "slippage": 1,
-        "tokenIn": [
-          "0x20c0000000000000000000000000000000000000",
-          "0x20C000000000000000000000b9537d11c60E8b50",
-        ],
-      }
-    `)
-  })
-
-  test('custom tokenIn + custom slippage', () => {
-    const custom = '0x0000000000000000000000000000000000000099' as Address
-    expect(resolve({ tokenIn: [custom], slippage: 3 }, defaults)).toMatchInlineSnapshot(`
-      {
-        "slippage": 3,
-        "tokenIn": [
-          "0x0000000000000000000000000000000000000099",
-          "0x20c0000000000000000000000000000000000000",
-          "0x20C000000000000000000000b9537d11c60E8b50",
-        ],
-      }
-    `)
-  })
-})
-
-describe('findCalls', () => {
-  test('uses current viem Tempo call builder signatures', async () => {
-    vi.resetModules()
-    const account = '0x1111111111111111111111111111111111111111' as Address
-    const tokenOut = '0x2222222222222222222222222222222222222222' as Address
-    const tokenIn = '0x3333333333333333333333333333333333333333' as Address
-    const client = { chain: { id: 42431 } }
-    const builderCalls: { client: unknown; name: string; parameters: Record<string, unknown> }[] =
-      []
-
-    function getBalanceCall(client: unknown, parameters: Record<string, unknown>) {
-      builderCalls.push({ client, name: 'getBalance', parameters })
-      return { kind: parameters.token === tokenOut ? 'targetBalance' : 'candidateBalance' }
-    }
-
-    function approveCall(client: unknown, parameters: Record<string, unknown>) {
-      builderCalls.push({ client, name: 'approve', parameters })
-      return { kind: 'approve' }
-    }
-
-    function buyCall(parameters: Record<string, unknown>) {
-      builderCalls.push({ client: undefined, name: 'buy', parameters })
-      return { kind: 'buy' }
-    }
-
-    vi.doMock('viem/actions', () => ({
-      readContract: vi.fn(async (_client, call: { kind: string }) =>
-        call.kind === 'targetBalance' ? 0n : 2_000_000n,
-      ),
-    }))
-    vi.doMock('viem/tempo', () => ({
-      Actions: {
-        dex: {
-          buy: { call: buyCall },
-          getBuyQuote: vi.fn(async () => 1_000_000n),
-        },
-        token: {
-          approve: { call: approveCall },
-          getBalance: { call: getBalanceCall },
-        },
-      },
-      Addresses: { stablecoinDex: '0x4444444444444444444444444444444444444444' },
-    }))
-
-    try {
-      const { findCalls } = await import('./auto-swap.js')
-
-      const calls = await findCalls(client as never, {
-        account,
-        amountOut: 1_000_000n,
-        slippage: 1,
-        tokenIn: [tokenIn],
-        tokenOut,
-      })
-
-      expect(calls).toHaveLength(2)
-      expect(builderCalls.map((call) => call.client)).toEqual([client, client, client, undefined])
-      expect(builderCalls.map((call) => call.name)).toEqual([
-        'getBalance',
-        'getBalance',
-        'approve',
-        'buy',
-      ])
-      expect(builderCalls[0]!.parameters).toMatchObject({ account, token: tokenOut })
-      expect(builderCalls[1]!.parameters).toMatchObject({ account, token: tokenIn })
-      expect(builderCalls[2]!.parameters).toMatchObject({
-        amount: 1_010_000n,
-        spender: '0x4444444444444444444444444444444444444444',
-        token: tokenIn,
-      })
-      expect(builderCalls[3]!.parameters).toMatchObject({
-        amountOut: 1_000_000n,
-        maxAmountIn: 1_010_000n,
-        tokenIn,
-        tokenOut,
-      })
-    } finally {
-      vi.doUnmock('viem/actions')
-      vi.doUnmock('viem/tempo')
-      vi.resetModules()
-    }
-  })
-})
-
-describe('InsufficientFundsError', () => {
-  test('default', () => {
-    const error = new InsufficientFundsError({
-      currency: '0x0000000000000000000000000000000000000001',
-    })
-    expect(error).toMatchInlineSnapshot(
-      `[InsufficientFundsError: Insufficient funds: no balance in 0x0000000000000000000000000000000000000001 and no viable swap route from fallback currencies.]`,
-    )
-  })
-})

package/src/tempo/internal/auto-swap.ts

@@ -1,145 +0,0 @@
-import type { Address, Client } from 'viem'
-import { readContract } from 'viem/actions'
-import { Actions, Addresses } from 'viem/tempo'
-
-import * as TempoAddress from './address.js'
-import * as defaults from './defaults.js'
-
-/** Basis-point denominator (100% = 10 000 bps). */
-const bps = 10_000n
-
-/** Default fallback currencies for auto-swap, in priority order. */
-export const defaultCurrencies: readonly Address[] = [
-  defaults.tokens.pathUsd as Address,
-  defaults.tokens.usdc as Address,
-]
-
-/**
- * Finds the optimal swap calls to acquire `amountOut` of `tokenOut`,
- * returning an approve + buy call sequence if a viable route is found.
- *
- * Returns `undefined` if the account already holds enough of `tokenOut`
- * or no viable swap route exists from the given input tokens.
- */
-export async function findCalls(
-  client: Client,
-  parameters: findCalls.Parameters,
-): Promise<findCalls.ReturnType> {
-  const { account, amountOut, tokenOut, tokenIn, slippage } = parameters
-
-  const candidates = tokenIn.filter((t) => !TempoAddress.isEqual(t, tokenOut))
-
-  const balanceResults = await Promise.allSettled([
-    readContract(
-      client,
-      Actions.token.getBalance.call(client, { account, token: tokenOut }) as never,
-    ),
-    ...candidates.map((t) =>
-      readContract(client, Actions.token.getBalance.call(client, { account, token: t }) as never),
-    ),
-  ])
-
-  // If the account already has enough of the target token, no swap needed.
-  const targetBalance = balanceResults[0]!
-  if (targetBalance.status === 'fulfilled' && (targetBalance.value as bigint) >= amountOut)
-    return undefined
-
-  // Find first candidate with enough balance to cover a swap.
-  for (let i = 0; i < candidates.length; i++) {
-    const result = balanceResults[i + 1]!
-    if (result.status !== 'fulfilled') continue
-
-    const balance = result.value as bigint
-    if (balance <= 0n) continue
-
-    const tokenIn = candidates[i]!
-
-    try {
-      const quotedAmountIn = await Actions.dex.getBuyQuote(client as never, {
-        tokenIn,
-        tokenOut,
-        amountOut,
-      })
-
-      if (balance >= quotedAmountIn) {
-        const maxAmountIn =
-          quotedAmountIn + (quotedAmountIn * BigInt(Math.round(slippage * 100))) / bps
-        return [
-          Actions.token.approve.call(client, {
-            amount: maxAmountIn,
-            spender: Addresses.stablecoinDex,
-            token: tokenIn,
-          }),
-          Actions.dex.buy.call({
-            tokenIn,
-            tokenOut,
-            amountOut,
-            maxAmountIn,
-          }),
-        ]
-      }
-    } catch {}
-  }
-
-  throw new InsufficientFundsError({ currency: tokenOut })
-}
-
-export declare namespace findCalls {
-  type Parameters = {
-    /** Address of the account to check balances for. */
-    account: Address
-    /** Amount of the target token needed. */
-    amountOut: bigint
-    /** Candidate input tokens to swap from, in priority order. */
-    tokenIn: readonly Address[]
-    /** Max slippage tolerance as a percentage (e.g. `1` = 1%). */
-    slippage: number
-    /** Address of the target token to acquire. */
-    tokenOut: Address
-  }
-
-  /** `undefined` when no swap is needed (account has sufficient balance). */
-  type ReturnType = readonly object[] | undefined
-}
-
-/** Resolves an auto-swap configuration value into concrete currencies and slippage. */
-export function resolve(
-  value: resolve.Value | undefined,
-  defaultCurrencies: readonly Address[],
-): resolve.Resolved | false {
-  if (!value) return false
-  if (value === true) return { tokenIn: defaultCurrencies, slippage: 1 }
-  const tokenIn = value.tokenIn
-    ? [
-        ...value.tokenIn,
-        ...defaultCurrencies.filter((d) => !value.tokenIn!.some((c) => TempoAddress.isEqual(c, d))),
-      ]
-    : defaultCurrencies
-  return {
-    tokenIn,
-    slippage: value.slippage ?? 1,
-  }
-}
-
-export declare namespace resolve {
-  type Options = {
-    /** Fallback tokens to try swapping from, in priority order. */
-    tokenIn?: Address[] | undefined
-    /** Max slippage tolerance as a percentage (e.g. `1` = 1%). @default 1 */
-    slippage?: number | undefined
-  }
-
-  type Value = boolean | Options
-
-  type Resolved = { tokenIn: readonly Address[]; slippage: number }
-}
-
-export class InsufficientFundsError extends Error {
-  override readonly name = 'InsufficientFundsError'
-
-  constructor({ currency }: { currency: Address }) {
-    super(
-      `Insufficient funds: no balance in ${currency} and no viable swap route from fallback currencies.`,
-    )
-  }
-}

package/src/tempo/internal/charge.test.ts

@@ -1,66 +0,0 @@
-import type { Address } from 'viem'
-import { describe, expect, test } from 'vp/test'
-
-import { getTransfers } from './charge.js'
-
-const recipient = '0x1234567890abcdef1234567890abcdef12345678' as Address
-
-describe('getTransfers', () => {
-  test('returns single transfer when no splits', () => {
-    const transfers = getTransfers({ amount: '100', recipient })
-    expect(transfers).toEqual([{ amount: '100', memo: undefined, recipient }])
-  })
-
-  test('splits amount between primary and split recipients', () => {
-    const splitRecipient = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as Address
-    const transfers = getTransfers({
-      amount: '100',
-      methodDetails: { splits: [{ amount: '30', recipient: splitRecipient }] },
-      recipient,
-    })
-    expect(transfers).toHaveLength(2)
-    expect(transfers[0]!.amount).toBe('70')
-    expect(transfers[0]!.recipient).toBe(recipient)
-    expect(transfers[1]!.amount).toBe('30')
-    expect(transfers[1]!.recipient).toBe(splitRecipient)
-  })
-
-  test('throws when amount is zero with no splits', () => {
-    expect(() => getTransfers({ amount: '0', recipient })).toThrow(
-      'split total must be less than total amount',
-    )
-  })
-
-  test('throws when amount is zero with splits', () => {
-    const splitRecipient = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as Address
-    expect(() =>
-      getTransfers({
-        amount: '0',
-        methodDetails: { splits: [{ amount: '0', recipient: splitRecipient }] },
-        recipient,
-      }),
-    ).toThrow()
-  })
-
-  test('throws when split total equals amount', () => {
-    const splitRecipient = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as Address
-    expect(() =>
-      getTransfers({
-        amount: '100',
-        methodDetails: { splits: [{ amount: '100', recipient: splitRecipient }] },
-        recipient,
-      }),
-    ).toThrow('split total must be less than total amount')
-  })
-
-  test('throws when split total exceeds amount', () => {
-    const splitRecipient = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as Address
-    expect(() =>
-      getTransfers({
-        amount: '100',
-        methodDetails: { splits: [{ amount: '200', recipient: splitRecipient }] },
-        recipient,
-      }),
-    ).toThrow('split total must be less than total amount')
-  })
-})

package/src/tempo/internal/charge.ts

@@ -1,43 +0,0 @@
-import type { Address } from 'viem'
-
-export type Split = {
-  amount: string
-  memo?: string | undefined
-  recipient: Address
-}
-
-export type Transfer = {
-  amount: string
-  memo?: string | undefined
-  recipient: Address
-}
-
-export function getTransfers(request: {
-  amount: string
-  methodDetails?: { memo?: string | undefined; splits?: readonly Split[] | undefined }
-  recipient: Address
-}): Transfer[] {
-  const totalAmount = BigInt(request.amount)
-  const splits = request.methodDetails?.splits ?? []
-
-  const splitTotal = splits.reduce((sum, split) => sum + BigInt(split.amount), 0n)
-  if (splitTotal >= totalAmount)
-    throw new Error('Invalid charge request: split total must be less than total amount.')
-
-  const primaryAmount = totalAmount - splitTotal
-  if (primaryAmount <= 0n)
-    throw new Error('Invalid charge request: primary transfer amount must be positive.')
-
-  return [
-    {
-      amount: primaryAmount.toString(),
-      memo: request.methodDetails?.memo,
-      recipient: request.recipient,
-    },
-    ...splits.map((split) => ({
-      amount: split.amount,
-      memo: split.memo,
-      recipient: split.recipient,
-    })),
-  ]
-}

package/src/tempo/internal/defaults.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import {
-  chainId,
-  currency,
-  decimals,
-  escrowContract,
-  resolveCurrency,
-  rpcUrl,
-  tokens,
-} from './defaults.js'
-
-describe('chain ID constants', () => {
-  test('mainnet is 4217', () => {
-    expect(chainId.mainnet).toBe(4217)
-  })
-
-  test('testnet is 42431', () => {
-    expect(chainId.testnet).toBe(42431)
-  })
-})
-
-describe('token address constants', () => {
-  test('usdc address', () => {
-    expect(tokens.usdc).toBe('0x20C000000000000000000000b9537d11c60E8b50')
-  })
-
-  test('pathUsd address', () => {
-    expect(tokens.pathUsd).toBe('0x20c0000000000000000000000000000000000000')
-  })
-
-  test('usdc and pathUsd are different addresses', () => {
-    expect(tokens.usdc).not.toBe(tokens.pathUsd)
-  })
-
-  test('decimals is 6', () => {
-    expect(decimals).toBe(6)
-  })
-})
-
-describe('rpcUrl', () => {
-  test('mainnet RPC URL', () => {
-    expect(rpcUrl[chainId.mainnet]).toBe('https://rpc.tempo.xyz')
-  })
-
-  test('testnet RPC URL', () => {
-    expect(rpcUrl[chainId.testnet]).toBe('https://rpc.moderato.tempo.xyz')
-  })
-})
-
-describe('escrowContract', () => {
-  test('mainnet escrow contract', () => {
-    expect(escrowContract[chainId.mainnet]).toBe('0x33b901018174DDabE4841042ab76ba85D4e24f25')
-  })
-
-  test('testnet escrow contract', () => {
-    expect(escrowContract[chainId.testnet]).toBe('0xe1c4d3dce17bc111181ddf716f75bae49e61a336')
-  })
-})
-
-describe('currency', () => {
-  test('mainnet (4217) returns USDC', () => {
-    expect(currency[chainId.mainnet]).toBe(tokens.usdc)
-  })
-
-  test('testnet (42431) returns pathUSD', () => {
-    expect(currency[chainId.testnet]).toBe(tokens.pathUsd)
-  })
-
-  test('mainnet and testnet return different currencies', () => {
-    expect(currency[chainId.mainnet]).not.toBe(currency[chainId.testnet])
-  })
-})
-
-describe('resolveCurrency', () => {
-  test('defaults to USDC (mainnet)', () => {
-    expect(resolveCurrency({})).toBe(tokens.usdc)
-  })
-
-  test('testnet: true returns pathUSD', () => {
-    expect(resolveCurrency({ testnet: true })).toBe(tokens.pathUsd)
-  })
-
-  test('testnet: false returns USDC', () => {
-    expect(resolveCurrency({ testnet: false })).toBe(tokens.usdc)
-  })
-
-  test('chainId takes precedence over testnet', () => {
-    expect(resolveCurrency({ chainId: chainId.testnet, testnet: false })).toBe(tokens.pathUsd)
-  })
-
-  test('unknown chainId falls back to pathUSD', () => {
-    expect(resolveCurrency({ chainId: 999999 })).toBe(tokens.pathUsd)
-  })
-})