tapimo 0.13.0 → 0.15.0

package/src/internal/funding/Transfer.ts

@@ -1,545 +0,0 @@
-import * as z from 'zod/mini'
-
-import type * as Db from '../../db/Db.js'
-import * as FundingTransferEvents from '../../db/tables/fundingTransferEvents.js'
-import * as FundingTransfers from '../../db/tables/fundingTransfers.js'
-import * as Id from '../Id.js'
-import * as OpenApi from '../OpenApi.js'
-import * as Schema from '../Schema.js'
-import * as Action from './Action.js'
-import * as Provider from './Provider.js'
-
-/** Public funding transfer statuses, in the order documented by the API. */
-export const statuses = [
-  'awaiting-source',
-  'processing',
-  'refunding',
-  'completed',
-  'refunded',
-  'action-required',
-  'expired',
-] as const
-
-/** Lifecycle status of a funding transfer. */
-export type Status = (typeof statuses)[number]
-
-/** Statuses that never change again after verified chain evidence. */
-export const terminalStatuses = ['completed', 'expired', 'refunded'] as const satisfies readonly Status[] // prettier-ignore
-
-/** Funding methods a caller can select at creation. */
-export const methods = ['depositAddress', 'transaction'] as const
-
-/** Funding method selected at creation. */
-export type Method = (typeof methods)[number]
-
-/** Amount modes a caller can select at creation. */
-export const modes = ['exactDestination', 'exactSource'] as const
-
-/** Amount mode selected at creation. */
-export type Mode = (typeof modes)[number]
-
-/** Customer-safe codes explaining an `action-required` or refund outcome. */
-export const statusReasonCodes = [
-  'destination_amount_below_minimum',
-  'destination_recovered',
-  'manual_recovery_required',
-  'refund_failed',
-  'source_amount_above_maximum',
-  'source_amount_below_minimum',
-  'source_chain_mismatch',
-  'source_token_mismatch',
-] as const
-
-/** Stable customer-safe status reason code. */
-export type StatusReasonCode = (typeof statusReasonCodes)[number]
-
-// The public state chart has no exits from `action-required`, but late chain
-// evidence or operator-triggered reconciliation may still resolve one, so
-// evidence-driven exits stay allowed.
-const transitions: Record<Status, readonly Status[]> = {
-  'action-required': ['completed', 'processing', 'refunded', 'refunding'],
-  'awaiting-source': ['action-required', 'expired', 'processing'],
-  completed: [],
-  expired: [],
-  processing: ['action-required', 'completed', 'refunding'],
-  refunded: [],
-  refunding: ['action-required', 'refunded'],
-}
-
-/** Returns whether a status is terminal. */
-export function isTerminal(status: Status): boolean {
-  return (terminalStatuses as readonly Status[]).includes(status)
-}
-
-/** Returns whether the lifecycle allows moving from one status to another. */
-export function canTransition(from: Status, to: Status): boolean {
-  return transitions[from].includes(to)
-}
-
-/** Generates a funding transfer id (`ftr_…`, lexically time-ordered). */
-export function generateId(now: Date = new Date()): string {
-  return Id.generateSortable('ftr', now)
-}
-
-/** Zod schemas owned by the funding transfer resource. */
-export namespace schema {
-  /** Funding transfer lifecycle status. */
-  export const Status = z
-    .enum(statuses)
-    .check(
-      z.describe('Lifecycle status of the funding transfer.'),
-      z.meta({ examples: ['awaiting-source'] }),
-    )
-
-  /** Customer-safe explanation of a status that needs context. */
-  export const StatusReason = OpenApi.component(
-    z
-      .object({
-        code: z
-          .enum(statusReasonCodes)
-          .check(
-            z.describe('Stable machine-readable reason code.'),
-            z.meta({ examples: ['destination_amount_below_minimum'] }),
-          ),
-        message: z.string().check(
-          z.describe('Human-readable explanation of the reason.'),
-          z.meta({
-            examples: ['The verified destination amount did not satisfy the quoted minimum.'],
-          }),
-        ),
-      })
-      .check(z.describe('Why the transfer is in its current status, when context is needed.')),
-    'FundingTransferStatusReason',
-  )
-
-  /** Funding method selected at creation. */
-  export const Method = z
-    .enum(methods)
-    .check(z.describe('How the caller funds the transfer.'), z.meta({ examples: ['transaction'] }))
-
-  /** Amount mode selected at creation. */
-  export const Mode = z
-    .enum(modes)
-    .check(
-      z.describe('Which side of the transfer the quoted amount fixes.'),
-      z.meta({ examples: ['exactSource'] }),
-    )
-
-  /** One fee applied to the transfer. */
-  export const Fee = OpenApi.component(
-    z
-      .object({
-        amount: Schema.TokenAmount,
-        side: z
-          .enum(['destination', 'source'])
-          .check(
-            z.describe('Which side of the transfer the fee is taken from.'),
-            z.meta({ examples: ['destination'] }),
-          ),
-        token: Provider.schema.TokenRef,
-        type: z
-          .enum(['provider'])
-          .check(z.describe('What the fee pays for.'), z.meta({ examples: ['provider'] })),
-      })
-      .check(z.describe('One fee applied to the transfer.')),
-    'FundingTransferFee',
-  )
-
-  /** Freshness and validity window of the selected quote. */
-  export const Quote = OpenApi.component(
-    z
-      .object({
-        expiresAt: z.iso
-          .datetime()
-          .check(
-            z.describe('When the quoted terms stop being executable (ISO 8601).'),
-            z.meta({ examples: ['2026-07-30T04:01:00.000Z'] }),
-          ),
-        sampledAt: z.iso
-          .datetime()
-          .check(
-            z.describe('When the provider produced the quote (ISO 8601).'),
-            z.meta({ examples: ['2026-07-30T04:00:00.000Z'] }),
-          ),
-      })
-      .check(z.describe('Freshness and validity window of the selected quote.')),
-    'FundingTransferQuote',
-  )
-
-  const hashesCheck = (description: string) => [
-    z.describe(description),
-    z.meta({ examples: [[`0x${'aa'.repeat(32)}`]] }),
-  ]
-
-  const snapshotFields = {
-    destinationAmount: z.optional(Schema.TokenAmount),
-    destinationAmountMin: z.optional(Schema.TokenAmount),
-    destinationChain: Provider.schema.ChainRef,
-    destinationToken: Provider.schema.TokenRef,
-    destinationTransactionHashes: z.optional(
-      z.array(z.string()).check(...hashesCheck('Verified destination transaction references.')),
-    ),
-    fees: z.array(Fee).check(z.describe('Fees applied to the transfer.')),
-    method: Method,
-    mode: Mode,
-    provider: Provider.schema.ProviderRef,
-    quote: Quote,
-    recipient: z
-      .string()
-      .check(
-        z.describe('Final beneficiary of the transfer.'),
-        z.meta({ examples: [`0x${'11'.repeat(20)}`] }),
-      ),
-    refundAddress: z.optional(
-      z
-        .string()
-        .check(
-          z.describe('Source-chain refund recipient (deposit-address method).'),
-          z.meta({ examples: [`0x${'22'.repeat(20)}`] }),
-        ),
-    ),
-    refundAmount: z.optional(Schema.TokenAmount),
-    refundTransactionHashes: z.optional(
-      z.array(z.string()).check(...hashesCheck('Verified refund transaction references.')),
-    ),
-    sender: z.optional(
-      z
-        .string()
-        .check(
-          z.describe('Source-chain account that signs the funding action (transaction method).'),
-          z.meta({ examples: [`0x${'22'.repeat(20)}`] }),
-        ),
-    ),
-    sourceAmount: Schema.TokenAmount,
-    sourceAmountMax: z.optional(Schema.TokenAmount),
-    sourceChain: Provider.schema.ChainRef,
-    sourceToken: Provider.schema.TokenRef,
-    sourceTransactionHashes: z.optional(
-      z.array(z.string()).check(...hashesCheck('Verified source transaction references.')),
-    ),
-  }
-
-  /**
-   * The stored public snapshot: every transfer field except lifecycle columns
-   * (`id`, `status`, `statusReason`, `version`, `createdAt`, `updatedAt`),
-   * which live in typed columns and merge in at serialization.
-   */
-  export const Snapshot = z
-    .object(snapshotFields)
-    .check(z.describe('Quote terms and reconciled public fields of a funding transfer.'))
-
-  const fundingTransferFields = {
-    createdAt: z.iso
-      .datetime()
-      .check(
-        z.describe('When the transfer was created (ISO 8601).'),
-        z.meta({ examples: ['2026-07-30T04:00:00.000Z'] }),
-      ),
-    destinationAmount: snapshotFields.destinationAmount,
-    destinationAmountMin: snapshotFields.destinationAmountMin,
-    destinationChain: snapshotFields.destinationChain,
-    destinationToken: snapshotFields.destinationToken,
-    destinationTransactionHashes: snapshotFields.destinationTransactionHashes,
-    fees: snapshotFields.fees,
-    id: z
-      .string()
-      .check(
-        z.describe('Funding transfer id (`ftr_…`, lexically time-ordered).'),
-        z.meta({ examples: ['ftr_001785729600000_2ZPE2gvateYEQ0dQslgvkhjx'] }),
-      ),
-    method: snapshotFields.method,
-    mode: snapshotFields.mode,
-    provider: snapshotFields.provider,
-    quote: snapshotFields.quote,
-    recipient: snapshotFields.recipient,
-    refundAddress: snapshotFields.refundAddress,
-    refundAmount: snapshotFields.refundAmount,
-    refundTransactionHashes: snapshotFields.refundTransactionHashes,
-    sender: snapshotFields.sender,
-    sourceAmount: snapshotFields.sourceAmount,
-    sourceAmountMax: snapshotFields.sourceAmountMax,
-    sourceChain: snapshotFields.sourceChain,
-    sourceToken: snapshotFields.sourceToken,
-    sourceTransactionHashes: snapshotFields.sourceTransactionHashes,
-    status: Status,
-    statusReason: z.optional(StatusReason),
-    updatedAt: z.iso
-      .datetime()
-      .check(
-        z.describe('When the transfer last materially changed (ISO 8601).'),
-        z.meta({ examples: ['2026-07-30T04:00:20.000Z'] }),
-      ),
-    version: z
-      .number()
-      .check(
-        z.int(),
-        z.positive(),
-        z.describe('Monotonic revision that increments whenever the transfer materially changes.'),
-        z.meta({ examples: [1] }),
-      ),
-  }
-
-  /** A funding transfer as returned by reads. Reads never include `action`. */
-  export const FundingTransfer = OpenApi.component(
-    z.object(fundingTransferFields).check(z.describe('One durable funding transfer.')),
-    'FundingTransfer',
-  )
-
-  /** A created funding transfer: the read shape plus the executable action. */
-  export const CreatedFundingTransfer = OpenApi.component(
-    z
-      .object({ action: Action.schema.Action, ...fundingTransferFields })
-      .check(z.describe('The created funding transfer, including its one-time executable action.')),
-    'CreatedFundingTransfer',
-  )
-
-  /** Request body accepted by funding transfer creation. */
-  export const CreateRequest = OpenApi.component(
-    z
-      .strictObject({
-        amount: z
-          .string()
-          .check(
-            z.regex(/^[1-9]\d*$/),
-            z.describe('Amount in base units of the token the mode fixes.'),
-            z.meta({ examples: ['1000000'] }),
-          ),
-        destinationToken: z
-          .string()
-          .check(
-            z.minLength(1),
-            z.describe('Tempo destination token symbol, contract address, or token key.'),
-            z.meta({ examples: ['pathusd'] }),
-          ),
-        mode: Mode,
-        provider: z
-          .optional(z.string().check(z.minLength(1)))
-          .check(
-            z.describe('Funding provider ID. Omit to select the best available provider.'),
-            z.meta({ examples: ['relay'] }),
-          ),
-        recipient: z
-          .string()
-          .check(
-            z.regex(/^0x[0-9a-fA-F]{40}$/),
-            z.describe('Final beneficiary of the transfer.'),
-            z.meta({ examples: [`0x${'11'.repeat(20)}`] }),
-          ),
-        sender: z
-          .string()
-          .check(
-            z.regex(/^0x[0-9a-fA-F]{40}$/),
-            z.describe('Source-chain account that signs the funding action.'),
-            z.meta({ examples: [`0x${'22'.repeat(20)}`] }),
-          ),
-        slippageBps: z.optional(
-          z
-            .number()
-            .check(
-              z.int(),
-              z.gte(0),
-              z.lte(10_000),
-              z.describe('Maximum acceptable slippage in basis points.'),
-              z.meta({ examples: [50] }),
-            ),
-        ),
-        sourceChain: z
-          .string()
-          .check(
-            z.describe('Source chain CAIP-2 id, slug, or alias.'),
-            z.meta({ examples: ['base', 'eip155:8453'] }),
-          ),
-        sourceToken: z
-          .string()
-          .check(
-            z.minLength(1),
-            z.describe('Source token symbol, contract address, or token key.'),
-            z.meta({ examples: ['usdc'] }),
-          ),
-      })
-      .check(z.describe('Funding transfer creation request.')),
-    'CreateFundingTransferRequest',
-  )
-}
-
-/** Stored public snapshot of a funding transfer (see {@link schema.Snapshot}). */
-export type Snapshot = z.output<typeof schema.Snapshot>
-
-/** Customer-safe status reason (see {@link schema.StatusReason}). */
-export type StatusReason = z.output<typeof schema.StatusReason>
-
-/** A funding transfer as returned by reads (see {@link schema.FundingTransfer}). */
-export type Public = z.output<typeof schema.FundingTransfer>
-
-/** A created funding transfer (see {@link schema.CreatedFundingTransfer}). */
-export type Created = z.output<typeof schema.CreatedFundingTransfer>
-
-/** A validated creation request (see {@link schema.CreateRequest}). */
-export type CreateRequest = z.output<typeof schema.CreateRequest>
-
-/** What an associated transaction reference evidences. */
-export const transactionRoles = ['destination', 'refund', 'source'] as const
-
-/** Role of a verified transaction reference on a transfer. */
-export type TransactionRole = (typeof transactionRoles)[number]
-
-/**
- * Creates a durable funding transfer: the row plus its version-1 event commit
- * in one transaction, so every stored version has an immutable public record.
- */
-export async function create(db: Db.Db, input: create.Input): Promise<FundingTransfers.Record> {
-  return db.transaction((tx) => createIn(tx, input))
-}
-
-/**
- * Creates the transfer row and its version-1 event inside the caller's
- * transaction, for writes that must commit atomically with sibling state
- * (idempotency completion).
- */
-export async function createIn(tx: Db.Db, input: create.Input): Promise<FundingTransfers.Record> {
-  const now = new Date()
-  const snapshot = parseSnapshot(input.snapshot)
-  const record: FundingTransfers.Record = {
-    apiKeyId: input.apiKeyId,
-    createdAt: now.toISOString(),
-    environment: input.environment,
-    id: input.id ?? generateId(now),
-    method: snapshot.method,
-    mode: snapshot.mode,
-    orgId: input.orgId,
-    projectId: input.projectId ?? null,
-    providerId: snapshot.provider.id,
-    providerState: input.providerState ?? null,
-    quoteExpiresAt: snapshot.quote.expiresAt,
-    snapshot,
-    status: 'awaiting-source',
-    statusReason: null,
-    updatedAt: now.toISOString(),
-    version: 1,
-  }
-  const created = await FundingTransfers.insert(tx, record)
-  await FundingTransferEvents.insert(tx, {
-    createdAt: record.createdAt,
-    snapshot: toPublic(created),
-    status: created.status,
-    transferId: created.id,
-    version: created.version,
-  })
-  return created
-}
-
-export declare namespace create {
-  /** Fields required to create a funding transfer. */
-  type Input = {
-    /** API key that created the transfer. */
-    apiKeyId: string
-    /** Key environment the transfer belongs to. */
-    environment: 'production' | 'sandbox'
-    /** Transfer id override for deterministic tests. */
-    id?: string | undefined
-    /** Owning organization id (`org_…`). */
-    orgId: string
-    /** Attributed project id, when the creating key is project-attributed. */
-    projectId?: string | undefined
-    /** Private provider correlation retained for reconciliation. */
-    providerState?: Provider.prepareTransfer.Correlation | undefined
-    /** The public snapshot captured from the selected quote. */
-    snapshot: Snapshot
-  }
-}
-
-/**
- * Applies a version-guarded material change: a status transition, a snapshot
- * update, or both. The row update and its immutable event commit in one
- * transaction; a stale `expectedVersion` or disallowed transition applies
- * nothing, so concurrent observations cannot overwrite newer evidence.
- */
-export async function transition(
-  db: Db.Db,
-  options: transition.Options,
-): Promise<transition.Result> {
-  const now = new Date()
-  return db.transaction(async (tx) => {
-    const current = await FundingTransfers.get(tx, options.id)
-    if (!current) return { type: 'not_found' }
-    if (current.version !== options.expectedVersion) return { current, type: 'stale' }
-    const status = options.status ?? current.status
-    if (status !== current.status && !canTransition(current.status, status))
-      return { current, type: 'invalid' }
-
-    const updated = await FundingTransfers.update(tx, {
-      expectedVersion: options.expectedVersion,
-      id: options.id,
-      snapshot: options.snapshot === undefined ? current.snapshot : parseSnapshot(options.snapshot),
-      status,
-      statusReason:
-        options.statusReason ?? (status === current.status ? current.statusReason : null),
-      updatedAt: now.toISOString(),
-      version: current.version + 1,
-    })
-    if (!updated) {
-      const latest = await FundingTransfers.get(tx, options.id)
-      return latest ? { current: latest, type: 'stale' } : { type: 'not_found' }
-    }
-    await FundingTransferEvents.insert(tx, {
-      createdAt: updated.updatedAt,
-      snapshot: toPublic(updated),
-      status: updated.status,
-      transferId: updated.id,
-      version: updated.version,
-    })
-    return { record: updated, type: 'applied' }
-  })
-}
-
-export declare namespace transition {
-  /** Fields describing a material change to apply. */
-  type Options = {
-    /** The version the change was computed against. */
-    expectedVersion: number
-    /** Transfer id (`ftr_…`). */
-    id: string
-    /** Replacement public snapshot; omitted keeps the stored snapshot. */
-    snapshot?: Snapshot | undefined
-    /** New status; omitted keeps the current status (snapshot-only change). */
-    status?: Status | undefined
-    /** Customer-safe reason attached to the new status. */
-    statusReason?: StatusReason | undefined
-  }
-
-  /** Outcome of a guarded transition. */
-  type Result =
-    | { record: FundingTransfers.Record; type: 'applied' }
-    | { current: FundingTransfers.Record; type: 'invalid' }
-    | { current: FundingTransfers.Record; type: 'stale' }
-    | { type: 'not_found' }
-}
-
-/** Serializes a created row with its one-time executable action. */
-export function toCreated(record: FundingTransfers.Record, action: Action.Action): Created {
-  return schema.CreatedFundingTransfer.parse({ action, ...toPublic(record) })
-}
-
-/** Serializes a stored row to the public read shape. Never includes actions. */
-export function toPublic(record: FundingTransfers.Record): Public {
-  return schema.FundingTransfer.parse({
-    ...record.snapshot,
-    createdAt: record.createdAt,
-    id: record.id,
-    status: record.status,
-    ...(record.statusReason === null ? {} : { statusReason: record.statusReason }),
-    updatedAt: record.updatedAt,
-    version: record.version,
-  })
-}
-
-function parseSnapshot(snapshot: Snapshot): Snapshot {
-  const parsed = schema.Snapshot.parse(snapshot)
-  return {
-    ...parsed,
-    quote: {
-      ...parsed.quote,
-      expiresAt: new Date(parsed.quote.expiresAt).toISOString(),
-    },
-  }
-}

package/src/internal/funding/providers/stargate.test.ts

@@ -1,163 +0,0 @@
-import { AbiFunction, Hex } from 'ox'
-
-import type * as Action from '../Action.js'
-import type * as Catalog from '../Catalog.js'
-import * as FundingProvider from '../Provider.js'
-import * as Stargate from './stargate.js'
-
-const amount = 1_000_000n
-const destinationToken = '0x20C000000000000000000000b9537d11c60E8b50'
-const nativeFee = 10_000n
-const otherAddress = '0x9999999999999999999999999999999999999999'
-const pool = '0x27a16dc786820B16E5c9028b75B99F6f604b5d26'
-const recipient = '0x1111111111111111111111111111111111111111'
-const sender = '0x2222222222222222222222222222222222222222'
-const sourceToken = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
-
-const approve = AbiFunction.from('function approve(address spender, uint256 amount)')
-const sendToken = AbiFunction.from(
-  'function sendToken((uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, (uint256 nativeFee, uint256 lzTokenFee) fee, address refundAddress) payable returns ((bytes32 guid, uint64 nonce, (uint256 nativeFee, uint256 lzTokenFee) fee) msgReceipt, (uint256 amountSentLD, uint256 amountReceivedLD) oftReceipt, (uint72 ticketId, bytes passengerBytes) ticket)',
-)
-
-describe('stargate', () => {
-  test('creates a credential-free quote and transfer provider', () => {
-    expect(Stargate.stargate()).toMatchObject({
-      getQuote: expect.any(Function),
-      id: 'stargate',
-      name: 'Stargate',
-      prepareTransfer: expect.any(Function),
-    })
-  })
-})
-
-describe('validateAction', () => {
-  test('accepts the exact approval and Taxi send calls', () => {
-    expect(validate(action())).toEqual([{ to: pool, value: Hex.fromNumber(nativeFee) }])
-  })
-
-  test('rejects calls outside the curated Stargate route', () => {
-    const invalid = [
-      action({ approvalAmount: amount + 1n }),
-      action({ approvalSpender: otherAddress }),
-      action({ composeMsg: '0x01' }),
-      action({ destinationEid: 1 }),
-      action({ executionTarget: otherAddress }),
-      action({ extraOptions: '0x01' }),
-      action({ lzTokenFee: 1n }),
-      action({ minimumAmount: amount - 1n }),
-      action({ oftCmd: '0x01' }),
-      action({ recipient: otherAddress }),
-      action({ refundAddress: otherAddress }),
-      action({ sourceAmount: amount + 1n }),
-    ]
-    for (const candidate of invalid)
-      expect(() => validate(candidate)).toThrowError(FundingProvider.ProviderPayloadError)
-    expect(() => validate(action(), { sourceTokenAddress: otherAddress })).toThrowError(
-      FundingProvider.ProviderPayloadError,
-    )
-    expect(() => validate(action(), { destinationTokenAddress: otherAddress })).toThrowError(
-      FundingProvider.ProviderPayloadError,
-    )
-  })
-
-  test('rejects malformed selectors and mismatched native value', () => {
-    const malformed = action()
-    malformed.calls[1]!.data = '0xdeadbeef'
-    expect(() => validate(malformed)).toThrowError(FundingProvider.ProviderPayloadError)
-
-    const mismatched = action()
-    mismatched.calls[1]!.value = Hex.fromNumber(nativeFee + 1n)
-    expect(() => validate(mismatched)).toThrowError(FundingProvider.ProviderPayloadError)
-  })
-
-  test('rejects missing or mismatched route configuration', () => {
-    expect(() =>
-      Stargate.validateAction({
-        action: action(),
-        destinationTokenAddress: destinationToken,
-        recipient,
-        sender,
-        sourceAmount: amount.toString(),
-        sourceChainId: 'eip155:8453',
-        sourceTokenAddress: sourceToken,
-      }),
-    ).toThrowError(FundingProvider.ProviderPayloadError)
-    expect(() => validate(action(), { configuration: { poolAddress: otherAddress } })).toThrowError(
-      FundingProvider.ProviderPayloadError,
-    )
-  })
-})
-
-function action(options: action.Options = {}): Action.EvmCalls {
-  const executionFee = options.nativeFee ?? nativeFee
-  const sendParam = {
-    amountLD: options.sourceAmount ?? amount,
-    composeMsg: options.composeMsg ?? '0x',
-    dstEid: options.destinationEid ?? 30_410,
-    extraOptions: options.extraOptions ?? '0x',
-    minAmountLD: options.minimumAmount ?? amount,
-    oftCmd: options.oftCmd ?? '0x',
-    to: Hex.padLeft(options.recipient ?? recipient, 32),
-  } as const
-  return {
-    calls: [
-      {
-        data: AbiFunction.encodeData(approve, [
-          options.approvalSpender ?? pool,
-          options.approvalAmount ?? amount,
-        ]),
-        to: sourceToken,
-        value: '0x0',
-      },
-      {
-        data: AbiFunction.encodeData(sendToken, [
-          sendParam,
-          { lzTokenFee: options.lzTokenFee ?? 0n, nativeFee: executionFee },
-          options.refundAddress ?? sender,
-        ]),
-        to: options.executionTarget ?? pool,
-        value: Hex.fromNumber(executionFee),
-      },
-    ],
-    type: 'evm:calls',
-  }
-}
-
-declare namespace action {
-  type Options = {
-    approvalAmount?: bigint | undefined
-    approvalSpender?: `0x${string}` | undefined
-    composeMsg?: Hex.Hex | undefined
-    destinationEid?: number | undefined
-    executionTarget?: `0x${string}` | undefined
-    extraOptions?: Hex.Hex | undefined
-    lzTokenFee?: bigint | undefined
-    minimumAmount?: bigint | undefined
-    nativeFee?: bigint | undefined
-    oftCmd?: Hex.Hex | undefined
-    recipient?: Hex.Hex | undefined
-    refundAddress?: `0x${string}` | undefined
-    sourceAmount?: bigint | undefined
-  }
-}
-
-function validate(candidate: Action.EvmCalls, options: validate.Options = {}) {
-  return Stargate.validateAction({
-    action: candidate,
-    configuration: options.configuration ?? { poolAddress: pool },
-    destinationTokenAddress: options.destinationTokenAddress ?? destinationToken,
-    recipient,
-    sender,
-    sourceAmount: amount.toString(),
-    sourceChainId: 'eip155:8453',
-    sourceTokenAddress: options.sourceTokenAddress ?? sourceToken,
-  })
-}
-
-declare namespace validate {
-  type Options = {
-    configuration?: Catalog.Configuration | undefined
-    destinationTokenAddress?: string | undefined
-    sourceTokenAddress?: string | undefined
-  }
-}