mppx 0.8.15 → 0.8.18

package/src/tempo/client/Subscription.ts

@@ -1,156 +0,0 @@
-import { Hex } from 'ox'
-import { KeyAuthorization } from 'ox/tempo'
-import { isAddressEqual, type Address } from 'viem'
-import { tempo as tempo_chain } from 'viem/tempo/chains'
-
-import * as Credential from '../../Credential.js'
-import type { MaybePromise } from '../../internal/types.js'
-import * as Method from '../../Method.js'
-import * as Account from '../../viem/Account.js'
-import * as Client from '../../viem/Client.js'
-import * as z from '../../zod.js'
-import * as defaults from '../internal/defaults.js'
-import * as Methods from '../Methods.js'
-import {
-  getSubscriptionScopes,
-  signSubscriptionKeyAuthorization,
-  toSubscriptionExpiryDate,
-  toSubscriptionExpirySeconds,
-  toSubscriptionPeriodSeconds,
-  verifySubscriptionKeyAuthorization,
-} from '../subscription/KeyAuthorization.js'
-import type { SubscriptionAccessKey } from '../subscription/Types.js'
-
-type SubscriptionRequest = ReturnType<typeof Methods.subscription.schema.request.parse>
-
-/** Context accepted by the Tempo subscription client method. */
-export const subscriptionContextSchema = z.object({
-  accessKey: z.optional(z.custom<SubscriptionAccessKey>()),
-  account: z.optional(z.custom<Account.getResolver.Parameters['account']>()),
-})
-
-/** Runtime context for creating a Tempo subscription credential. */
-export type SubscriptionContext = z.infer<typeof subscriptionContextSchema>
-
-/** Creates a Tempo subscription client method. */
-export function subscription(parameters: subscription.Parameters = {}) {
-  const getClient = Client.getResolver({
-    chain: tempo_chain,
-    getClient: parameters.getClient,
-    rpcUrl: defaults.rpcUrl,
-  })
-  const getAccount = Account.getResolver({ account: parameters.account })
-
-  return Method.toClient(Methods.subscription, {
-    context: subscriptionContextSchema,
-
-    async createCredential({ challenge, context }) {
-      const chainId = challenge.request.methodDetails?.chainId ?? defaults.chainId.testnet
-      const client = await getClient({ chainId })
-      const account = getAccount(client, context)
-      const accessKey =
-        context?.accessKey ?? parameters.accessKey ?? challenge.request.methodDetails?.accessKey
-      if (!accessKey) {
-        throw new Error(
-          'No `accessKey` provided. The subscription challenge must include `accessKey`, or the client must pass one to parameters/context.',
-        )
-      }
-
-      assertSubscriptionRequestRepresentable(challenge.request)
-      await parameters.validateRequest?.(challenge.request)
-
-      const keyAuthorization = await authorizeAccessKey(client, {
-        accessKey,
-        account,
-        chainId,
-        request: challenge.request,
-      } as never)
-
-      const verified = verifySubscriptionKeyAuthorization({
-        accessKey,
-        chainId,
-        payload: {
-          signature: KeyAuthorization.serialize(keyAuthorization as never),
-          type: 'keyAuthorization',
-        },
-        request: challenge.request,
-      })
-      if (!isAddressEqual(verified.source.address, account.address)) {
-        throw new Error('keyAuthorization signer does not match the selected account')
-      }
-
-      return Credential.serialize({
-        challenge,
-        payload: {
-          signature: KeyAuthorization.serialize(keyAuthorization as never),
-          type: 'keyAuthorization',
-        },
-        source: `did:pkh:eip155:${chainId}:${account.address.toLowerCase()}`,
-      })
-    },
-  })
-}
-
-async function authorizeAccessKey(
-  client: Awaited<ReturnType<ReturnType<typeof Client.getResolver>>>,
-  parameters: {
-    accessKey: SubscriptionAccessKey
-    account: Account.Account
-    chainId: number
-    request: Pick<
-      SubscriptionRequest,
-      'amount' | 'currency' | 'periodCount' | 'periodUnit' | 'recipient' | 'subscriptionExpires'
-    >
-  },
-) {
-  const { accessKey, account, chainId, request } = parameters
-
-  const local = await signSubscriptionKeyAuthorization({
-    accessKey,
-    account,
-    chainId,
-    request,
-  })
-  if (local) return local
-
-  const result = (await client.request({
-    method: 'wallet_authorizeAccessKey',
-    params: [
-      {
-        address: accessKey.accessKeyAddress,
-        expiry: toSubscriptionExpirySeconds(toSubscriptionExpiryDate(request.subscriptionExpires)),
-        keyType: accessKey.keyType,
-        limits: [
-          {
-            token: request.currency as Address,
-            limit: Hex.fromNumber(BigInt(request.amount)),
-            period: toSubscriptionPeriodSeconds(request),
-          },
-        ],
-        scopes: getSubscriptionScopes(request),
-      },
-    ],
-  } as never)) as {
-    keyAuthorization: Parameters<typeof KeyAuthorization.fromRpc>[0]
-  }
-
-  return KeyAuthorization.fromRpc(result.keyAuthorization)
-}
-
-function assertSubscriptionRequestRepresentable(request: SubscriptionRequest) {
-  toSubscriptionPeriodSeconds(request)
-  toSubscriptionExpirySeconds(toSubscriptionExpiryDate(request.subscriptionExpires))
-}
-
-export declare namespace subscription {
-  /** Parameters for creating a Tempo subscription credential. */
-  type Parameters = Account.getResolver.Parameters &
-    Client.getResolver.Parameters & {
-      accessKey?: SubscriptionAccessKey | undefined
-      validateRequest?:
-        | ((
-            request: ReturnType<typeof Methods.subscription.schema.request.parse>,
-          ) => MaybePromise<void>)
-        | undefined
-    }
-}

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.ts

@@ -1,6 +0,0 @@
-// TODO: Add `isEqual` to `TempoAddress`.
-import type { TempoAddress } from 'ox/tempo'
-
-export function isEqual(a: TempoAddress.Address, b: TempoAddress.Address) {
-  return a.toLowerCase() === 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('passes the client to viem 2.54 Tempo token call builders', 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(client: unknown, parameters: Record<string, unknown>) {
-      builderCalls.push({ client, 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, client])
-      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,188 +0,0 @@
-import type { Address, Client } from 'viem'
-import { readContract } from 'viem/actions'
-import { Actions, Addresses } from 'viem/tempo'
-import type { dex as viem_dex, token as viem_token } from 'viem/tempo/actions'
-
-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,
-]
-
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
-function getBalanceCall(
-  client: Client,
-  parameters: viem_token.getBalance.Args,
-): ReturnType<typeof viem_token.getBalance.call> {
-  const call = Actions.token.getBalance.call as unknown as {
-    length: number
-    (parameters: viem_token.getBalance.Args): ReturnType<typeof viem_token.getBalance.call>
-    (
-      client: Client,
-      parameters: viem_token.getBalance.Args,
-    ): ReturnType<typeof viem_token.getBalance.call>
-  }
-  return call.length >= 2 ? call(client, parameters) : call(parameters)
-}
-
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
-function getApproveCall(
-  client: Client,
-  parameters: viem_token.approve.Args,
-): ReturnType<typeof viem_token.approve.call> {
-  const call = Actions.token.approve.call as unknown as {
-    length: number
-    (parameters: viem_token.approve.Args): ReturnType<typeof viem_token.approve.call>
-    (
-      client: Client,
-      parameters: viem_token.approve.Args,
-    ): ReturnType<typeof viem_token.approve.call>
-  }
-  return call.length >= 2 ? call(client, parameters) : call(parameters)
-}
-
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
-function getBuyCall(
-  client: Client,
-  parameters: viem_dex.buy.Args,
-): ReturnType<typeof viem_dex.buy.call> {
-  const call = Actions.dex.buy.call as unknown as {
-    length: number
-    (parameters: viem_dex.buy.Args): ReturnType<typeof viem_dex.buy.call>
-    (client: Client, parameters: viem_dex.buy.Args): ReturnType<typeof viem_dex.buy.call>
-  }
-  return call.length >= 2 ? call(client, parameters) : call(parameters)
-}
-
-/**
- * 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, getBalanceCall(client, { account, token: tokenOut }) as never),
-    ...candidates.map((t) =>
-      readContract(client, getBalanceCall(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 [
-          getApproveCall(client, {
-            amount: maxAmountIn,
-            spender: Addresses.stablecoinDex,
-            token: tokenIn,
-          }),
-          getBuyCall(client, {
-            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')
-  })
-})