mppx 0.8.15 → 0.8.18

package/src/tempo/internal/fee-token.test.ts

@@ -1,165 +0,0 @@
-import type { Account } from 'viem'
-import { createClient } from 'viem'
-import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
-import { Actions, Addresses } from 'viem/tempo'
-import { describe, expect, test } from 'vp/test'
-import { tempoNetwork } from '~test/config.js'
-import { asset, chain, fundAccount, http } from '~test/tempo/viem.js'
-
-import { resolveFeeToken } from './fee-token.js'
-
-const isLocalnet = tempoNetwork === 'localnet'
-
-function clientFor(account: Account) {
-  return createClient({
-    account,
-    chain,
-    transport: http(),
-  })
-}
-
-function expectAddress(actual: string | undefined, expected: string) {
-  expect(actual?.toLowerCase()).toBe(expected.toLowerCase())
-}
-
-function testAccount() {
-  return privateKeyToAccount(generatePrivateKey())
-}
-
-describe.runIf(isLocalnet)('resolveFeeToken', () => {
-  test('uses the funded account fee preference first', async () => {
-    const account = testAccount()
-    const client = clientFor(account)
-    await fundAccount({ address: account.address, token: asset })
-    await Actions.fee.setUserTokenSync(client, {
-      feeToken: asset,
-      token: asset,
-    } as never)
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      candidateTokens: [Addresses.pathUsd],
-      client,
-    })
-
-    expectAddress(feeToken, asset)
-  })
-
-  test('falls through to the first funded candidate token', async () => {
-    const account = testAccount()
-    const client = clientFor(account)
-    await fundAccount({ address: account.address, token: asset })
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      candidateTokens: [Addresses.pathUsd, asset],
-      client,
-    })
-
-    expectAddress(feeToken, asset)
-  })
-
-  test('falls through from an unfunded account fee preference', async () => {
-    const account = testAccount()
-    const client = clientFor(account)
-    await fundAccount({ address: account.address, token: asset })
-    await Actions.fee.setUserTokenSync(client, {
-      feeToken: asset,
-      token: Addresses.pathUsd,
-    } as never)
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      candidateTokens: [asset],
-      client,
-    })
-
-    expectAddress(feeToken, asset)
-  })
-
-  test('prioritizes funded allowed candidates', async () => {
-    const account = testAccount()
-    const client = clientFor(account)
-    await fundAccount({ address: account.address, token: asset })
-    await fundAccount({ address: account.address, token: Addresses.pathUsd })
-    await Actions.fee.setUserTokenSync(client, {
-      feeToken: asset,
-      token: asset,
-    } as never)
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      allowedTokens: [Addresses.pathUsd, asset],
-      candidateTokens: [Addresses.pathUsd, asset],
-      client,
-      prioritizeCandidates: true,
-    })
-
-    expectAddress(feeToken, Addresses.pathUsd)
-  })
-
-  test('falls through prioritized candidates when pathUSD is unfunded', async () => {
-    const account = testAccount()
-    const client = clientFor(account)
-    await fundAccount({ address: account.address, token: asset })
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      allowedTokens: [Addresses.pathUsd, asset],
-      candidateTokens: [Addresses.pathUsd, asset],
-      client,
-      prioritizeCandidates: true,
-    })
-
-    expectAddress(feeToken, asset)
-  })
-
-  test('uses a funded chain fee token when configured', async () => {
-    const account = testAccount()
-    const client = createClient({
-      account,
-      chain: { ...chain, feeToken: asset },
-      transport: http(),
-    })
-    await fundAccount({ address: account.address, token: asset })
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      candidateTokens: [Addresses.pathUsd],
-      client,
-    })
-
-    expectAddress(feeToken, asset)
-  })
-
-  test('falls through from an unfunded chain fee token', async () => {
-    const account = testAccount()
-    const client = createClient({
-      account,
-      chain: { ...chain, feeToken: Addresses.pathUsd },
-      transport: http(),
-    })
-    await fundAccount({ address: account.address, token: asset })
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      candidateTokens: [asset],
-      client,
-    })
-
-    expectAddress(feeToken, asset)
-  })
-
-  test('falls back to the first known token when none are funded', async () => {
-    const account = testAccount()
-    const client = clientFor(account)
-
-    const feeToken = await resolveFeeToken({
-      account: account.address,
-      candidateTokens: [asset, Addresses.pathUsd],
-      client,
-    })
-
-    expectAddress(feeToken, asset)
-  })
-})

package/src/tempo/internal/fee-token.ts

@@ -1,72 +0,0 @@
-import type { Address, Client } from 'viem'
-import { Actions, TokenId } from 'viem/tempo'
-
-import * as TempoAddress from './address.js'
-import * as defaults from './defaults.js'
-
-function pushUnique(
-  tokens: Address[],
-  token: Address | undefined,
-  allowedTokens?: readonly Address[] | undefined,
-) {
-  if (!token) return
-  if (
-    allowedTokens &&
-    !allowedTokens.some((allowedToken) => TempoAddress.isEqual(allowedToken, token))
-  )
-    return
-  if (tokens.some((t) => TempoAddress.isEqual(t, token))) return
-  tokens.push(token)
-}
-
-async function hasBalance(client: Client, account: Address, token: Address): Promise<boolean> {
-  try {
-    return (await Actions.token.getBalance(client as never, { account, token })).amount > 0n
-  } catch {
-    return false
-  }
-}
-
-function getChainFeeToken(client: Client): Address | undefined {
-  const feeToken = (client.chain as { feeToken?: Address | bigint | undefined } | undefined)
-    ?.feeToken
-  if (feeToken) return TokenId.toAddress(feeToken)
-
-  const chainId = client.chain?.id
-  return chainId ? defaults.currency[chainId as keyof typeof defaults.currency] : undefined
-}
-
-/**
- * Resolves a funded fee token from account, chain, and caller-supplied preferences.
- *
- * `prioritizeCandidates` checks candidate tokens before account and chain
- * preferences. `allowedTokens` limits every preference to the caller's policy.
- */
-export async function resolveFeeToken(parameters: {
-  account: Address
-  allowedTokens?: readonly Address[] | undefined
-  candidateTokens?: readonly Address[] | undefined
-  client: Client
-  prioritizeCandidates?: boolean | undefined
-}): Promise<Address | undefined> {
-  const { account, allowedTokens, candidateTokens, client, prioritizeCandidates } = parameters
-  const tokens: Address[] = []
-
-  if (prioritizeCandidates)
-    for (const token of candidateTokens ?? []) pushUnique(tokens, token, allowedTokens)
-
-  const userToken = await Actions.fee
-    .getUserToken(client as never, { account })
-    .then((token) => token?.address as Address | undefined)
-    .catch(() => undefined)
-  pushUnique(tokens, userToken, allowedTokens)
-  pushUnique(tokens, getChainFeeToken(client), allowedTokens)
-  if (!prioritizeCandidates)
-    for (const token of candidateTokens ?? []) pushUnique(tokens, token, allowedTokens)
-
-  for (const token of tokens) {
-    if (await hasBalance(client, account, token)) return token
-  }
-
-  return tokens[0]
-}

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

@@ -1,97 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import * as Proof from './proof.js'
-
-const parsePkhSourceCases = [
-  {
-    expected: {
-      address: '0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-      chainId: 42431,
-    },
-    name: 'parses a valid did:pkh:eip155 source',
-    source: 'did:pkh:eip155:42431:0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-  },
-  {
-    expected: null,
-    name: 'rejects non-numeric chain ids',
-    source: 'did:pkh:eip155:not-a-number:0x1234',
-  },
-  {
-    expected: null,
-    name: 'rejects leading-zero chain ids',
-    source: 'did:pkh:eip155:01:0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-  },
-  {
-    expected: null,
-    name: 'rejects unsafe integer chain ids',
-    source: 'did:pkh:eip155:9007199254740992:0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-  },
-  {
-    expected: null,
-    name: 'rejects invalid addresses',
-    source: 'did:pkh:eip155:42431:not-an-address',
-  },
-  {
-    expected: null,
-    name: 'rejects extra path segments',
-    source: 'did:pkh:eip155:42431:0xAbCdEf1234567890AbCdEf1234567890AbCdEf12:extra',
-  },
-  {
-    expected: null,
-    name: 'rejects unsupported namespaces',
-    source: 'did:pkh:solana:42431:0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-  },
-] as const
-
-describe('Proof', () => {
-  test('types has Proof with account, challengeId and realm fields', () => {
-    expect(Proof.types).toEqual({
-      Proof: [
-        { name: 'account', type: 'address' },
-        { name: 'challengeId', type: 'string' },
-        { name: 'realm', type: 'string' },
-      ],
-    })
-  })
-
-  test('domain returns EIP-712 domain with name, version, chainId', () => {
-    const d = Proof.domain(42431)
-    expect(d).toEqual({ name: 'MPP', version: '3', chainId: 42431 })
-  })
-
-  test('domain uses provided chainId', () => {
-    expect(Proof.domain(1).chainId).toBe(1)
-    expect(Proof.domain(99999).chainId).toBe(99999)
-  })
-
-  test('message wraps account, challengeId and realm', () => {
-    expect(
-      Proof.message({
-        account: '0xAbCdEf1234567890AbCdEf1234567890AbCdEf12',
-        challengeId: 'abc123',
-        realm: 'api.example.com',
-      }),
-    ).toEqual({
-      account: '0xAbCdEf1234567890AbCdEf1234567890AbCdEf12',
-      challengeId: 'abc123',
-      realm: 'api.example.com',
-    })
-  })
-
-  test('proofSource constructs did:pkh DID', () => {
-    expect(Proof.proofSource({ address: '0x1234567890abcdef', chainId: 42431 })).toBe(
-      'did:pkh:eip155:42431:0x1234567890abcdef',
-    )
-  })
-
-  test('proofSource preserves address casing', () => {
-    const address = '0xAbCdEf1234567890AbCdEf1234567890AbCdEf12'
-    expect(Proof.proofSource({ address, chainId: 1 })).toBe(`did:pkh:eip155:1:${address}`)
-  })
-
-  for (const { expected, name, source } of parsePkhSourceCases) {
-    test(`parsePkhSource ${name}`, () => {
-      expect(Proof.parsePkhSource(source)).toEqual(expected)
-    })
-  }
-})

package/src/tempo/internal/proof.ts

@@ -1,87 +0,0 @@
-import { hashTypedData, isAddress, type Address, type Hex } from 'viem'
-
-/** EIP-712 primary type for proof credentials. */
-export const primaryType = 'Proof' as const
-
-/**
- * EIP-712 typed-data field definitions for Tempo zero-amount proof credentials.
- *
- * The `account` field cryptographically binds the signature to the payer
- * wallet, so a proof signed for one account cannot be replayed against another
- * — including across an access key that is authorized for multiple accounts.
- */
-export const types = {
-  Proof: [
-    { name: 'account', type: 'address' },
-    { name: 'challengeId', type: 'string' },
-    { name: 'realm', type: 'string' },
-  ],
-} as const
-
-/** Constructs the EIP-712 domain for a proof credential. */
-export function domain(chainId: number) {
-  return { name: 'MPP', version: '3', chainId } as const
-}
-
-/**
- * Constructs the EIP-712 message for a proof credential.
- *
- * @param parameters - Proof message parameters.
- * @param parameters.account - Payer wallet address the proof is bound to.
- * @param parameters.challengeId - Challenge `id` being proven.
- * @param parameters.realm - Challenge `realm` being proven.
- */
-export function message(parameters: { account: Address; challengeId: string; realm: string }) {
-  const { account, challengeId, realm } = parameters
-  return { account, challengeId, realm } as const
-}
-
-/**
- * Constructs the complete EIP-712 typed-data payload for a proof credential.
- *
- * This is the canonical, wallet-bound proof contract: signing this payload
- * commits the signer to a specific `account`, `challengeId`, and `realm`.
- */
-export function typedData(parameters: {
-  account: Address
-  chainId: number
-  challengeId: string
-  realm: string
-}) {
-  const { account, chainId, challengeId, realm } = parameters
-  return {
-    domain: domain(chainId),
-    types,
-    primaryType,
-    message: message({ account, challengeId, realm }),
-  } as const
-}
-
-/** Computes the EIP-712 digest (signing payload) for a proof credential. */
-export function hash(parameters: {
-  account: Address
-  chainId: number
-  challengeId: string
-  realm: string
-}): Hex {
-  return hashTypedData(typedData(parameters))
-}
-
-/** Constructs the expected `did:pkh` source DID for a proof credential. */
-export function proofSource(parameters: { address: string; chainId: number }): string {
-  return `did:pkh:eip155:${parameters.chainId}:${parameters.address}`
-}
-
-/** Parses a `did:pkh:eip155` source DID. */
-export function parsePkhSource(source: string): { address: Address; chainId: number } | null {
-  const match = /^did:pkh:eip155:(0|[1-9]\d*):([^:]+)$/.exec(source)
-  if (!match) return null
-
-  const chainIdText = match[1]!
-  const address = match[2]!
-  const chainId = Number(chainIdText)
-  if (!Number.isSafeInteger(chainId)) return null
-  if (!isAddress(address)) return null
-
-  return { address: address as Address, chainId }
-}

package/src/tempo/internal/selectors.ts

@@ -1,10 +0,0 @@
-import { AbiItem } from 'ox'
-import { Abis } from 'viem/tempo'
-
-export const approve = /*#__PURE__*/ AbiItem.getSelector(Abis.tip20, 'approve')
-export const transfer = /*#__PURE__*/ AbiItem.getSelector(Abis.tip20, 'transfer')
-export const transferWithMemo = /*#__PURE__*/ AbiItem.getSelector(Abis.tip20, 'transferWithMemo')
-export const swapExactAmountOut = /*#__PURE__*/ AbiItem.getSelector(
-  Abis.stablecoinDex,
-  'swapExactAmountOut',
-)

package/src/tempo/internal/types.ts

@@ -1,19 +0,0 @@
-import type { Account } from 'viem'
-
-import type { ConfiguredDefaults } from '../../internal/types.js'
-
-/**
- * Request defaults for a Tempo factory.
- *
- * Includes only caller configuration known to be defined, plus `resolved`
- * values that the factory creates unconditionally before returning its method.
- * This keeps the returned handler's required request fields aligned with the
- * values that will actually exist at runtime.
- */
-export type DeriveDefaults<parameters, defaults, resolved extends object = {}> = ConfiguredDefaults<
-  parameters,
-  defaults
-> &
-  resolved &
-  (parameters extends { account: Account | string } ? { recipient: string } : {}) &
-  (parameters extends { recipient: string } ? { recipient: string } : {})

package/src/tempo/legacy/AccessKeyAuthorization.test.ts

@@ -1,162 +0,0 @@
-import { type Address, createClient, custom, type Hex } from 'viem'
-import {
-  Account as TempoAccount,
-  KeyAuthorizationManager,
-  Secp256k1,
-  Transaction,
-} from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vp/test'
-import { tempoNetwork } from '~test/config.js'
-import { deployEscrow, openChannel } from '~test/tempo/legacy/session.js'
-import { asset as currency, chain, http } from '~test/tempo/viem.js'
-
-import { createOpenPayload } from './client/ChannelOps.js'
-import { closeOnChain, settleOnChain } from './session/Chain.js'
-import { signVoucher } from './session/Voucher.js'
-
-const rootAccount = TempoAccount.fromSecp256k1(
-  '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
-)
-const recipient = '0x2222222222222222222222222222222222222222' as Address
-const isLocalnet = tempoNetwork === 'localnet'
-
-async function createAccessKeyClient() {
-  const keyAuthorizationManager = KeyAuthorizationManager.memory()
-  const accessKey = TempoAccount.fromSecp256k1(Secp256k1.randomPrivateKey(), {
-    access: rootAccount,
-    keyAuthorizationManager,
-  })
-  const keyAuthorization = await rootAccount.signKeyAuthorization(
-    {
-      accessKeyAddress: accessKey.accessKeyAddress,
-      keyType: accessKey.keyType,
-    },
-    {
-      chainId: BigInt(chain.id),
-    },
-  )
-  await keyAuthorizationManager.set(
-    {
-      accessKey: accessKey.accessKeyAddress,
-      address: rootAccount.address,
-      chainId: chain.id,
-    },
-    keyAuthorization,
-  )
-
-  const signedTransactions: Transaction.TransactionSerializedTempo[] = []
-  const rpcClient = createClient({ chain, transport: http() })
-
-  const client = createClient({
-    account: accessKey,
-    chain,
-    transport: custom({
-      async request({ method, params }: { method: string; params?: readonly unknown[] }) {
-        if (method === 'eth_sendRawTransaction' || method === 'eth_sendRawTransactionSync')
-          signedTransactions.push(params?.[0] as Transaction.TransactionSerializedTempo)
-        return rpcClient.request({ method, params } as never)
-      },
-    }),
-  })
-
-  return { accessKey, client, keyAuthorization, signedTransactions }
-}
-
-function expectTransactionKeyAuthorization(
-  serializedTransaction: Hex,
-  keyAuthorization: Awaited<ReturnType<typeof rootAccount.signKeyAuthorization>>,
-) {
-  const transaction = Transaction.deserialize(
-    serializedTransaction as Transaction.TransactionSerializedTempo,
-  )
-  expect(transaction.keyAuthorization).toEqual(keyAuthorization)
-}
-
-async function createChannelForPayee(payee: Address, escrowContract: Address) {
-  const payer = rootAccount
-  const { channelId } = await openChannel({
-    deposit: 10_000_000n,
-    escrow: escrowContract,
-    payee,
-    payer,
-    salt: Secp256k1.randomPrivateKey(),
-    token: currency,
-  })
-  const cumulativeAmount = 1_000_000n
-  const signature = await signVoucher(
-    createClient({ account: payer, chain, transport: http() }),
-    payer,
-    { channelId, cumulativeAmount },
-    escrowContract,
-    chain.id,
-  )
-
-  return { channelId, cumulativeAmount, escrowContract, signature }
-}
-
-describe.runIf(isLocalnet)('legacy Tempo session access-key authorization attachment', () => {
-  let escrowContract: Address
-
-  beforeAll(async () => {
-    escrowContract = await deployEscrow()
-  })
-
-  test('open signs a prepared transaction with keyAuthorization', async () => {
-    const { accessKey, client, keyAuthorization } = await createAccessKeyClient()
-
-    const { payload } = await createOpenPayload(client, accessKey, {
-      chainId: chain.id,
-      currency,
-      deposit: 5_000_000n,
-      escrowContract,
-      initialAmount: 1_000_000n,
-      payee: recipient,
-    })
-
-    expect(payload.action).toBe('open')
-    if (payload.action !== 'open') throw new Error('unexpected payload action')
-    expectTransactionKeyAuthorization(payload.transaction, keyAuthorization)
-  })
-
-  test('settle sends a prepared transaction with keyAuthorization', async () => {
-    const { accessKey, client, keyAuthorization, signedTransactions } =
-      await createAccessKeyClient()
-    const channel = await createChannelForPayee(rootAccount.address, escrowContract)
-
-    const hash = await settleOnChain(
-      client,
-      channel.escrowContract,
-      {
-        channelId: channel.channelId,
-        cumulativeAmount: channel.cumulativeAmount,
-        signature: channel.signature,
-      },
-      { account: accessKey },
-    )
-
-    expect(hash).toMatch(/^0x[0-9a-f]{64}$/)
-    expect(signedTransactions).toHaveLength(1)
-    expectTransactionKeyAuthorization(signedTransactions[0]!, keyAuthorization)
-  })
-
-  test('close sends a prepared transaction with keyAuthorization', async () => {
-    const { accessKey, client, keyAuthorization, signedTransactions } =
-      await createAccessKeyClient()
-    const channel = await createChannelForPayee(rootAccount.address, escrowContract)
-
-    const hash = await closeOnChain(
-      client,
-      channel.escrowContract,
-      {
-        channelId: channel.channelId,
-        cumulativeAmount: channel.cumulativeAmount,
-        signature: channel.signature,
-      },
-      { account: accessKey },
-    )
-
-    expect(hash).toMatch(/^0x[0-9a-f]{64}$/)
-    expect(signedTransactions).toHaveLength(1)
-    expectTransactionKeyAuthorization(signedTransactions[0]!, keyAuthorization)
-  })
-})

package/src/tempo/legacy/README.md

@@ -1,9 +0,0 @@
-# Tempo Legacy Session
-
-This directory contains the legacy smart-contract-backed `tempo/session`
-implementation.
-
-The default `tempo.session` implementation is TIP-1034 precompile-backed and
-lives under `src/tempo/session/precompile`. Legacy code may import shared transport and
-accounting helpers from `src/tempo/session`, but legacy chain, channel, voucher,
-client, and server implementations should stay inside this directory.