tapimo 0.12.0 → 0.14.0

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

@@ -22,10 +22,7 @@ const providers = [
     integratorId: 'squid-integrator-id',
     userAddress: '0x1111111111111111111111111111111111111111',
   }),
-  Stargate.stargate({
-    apiKey: 'layerzero-api-key',
-    userAddress: '0x1111111111111111111111111111111111111111',
-  }),
+  Stargate.stargate(),
   Symbiosis.symbiosis({ userAddress: '0x1111111111111111111111111111111111111111' }),
 ] as const
 
@@ -340,126 +337,12 @@ describe('funding providers', () => {
     })
   })
 
-  test('maps the best Stargate quote to an available quote result', async () => {
-    const requests: RecordedRequest[] = []
-    const candidate = quoteCandidate('stargate')
-    const fetch = recordingFetch(requests, async () => jsonResponse(stargateQuotes(candidate)))
-    const provider = Stargate.stargate({
-      apiKey: 'layerzero-api-key',
-      baseUrl: 'https://layerzero.test/v1/',
-      fetch,
-      now,
-      userAddress: '0x1111111111111111111111111111111111111111',
-    })
-
-    const result = await provider.getQuote(getQuoteInput(candidate), new AbortController().signal)
-
-    expect(requests).toHaveLength(1)
-    expect(requests[0]?.url.pathname).toBe('/v1/quotes')
-    expect(new Headers(requests[0]?.init?.headers).get('user-agent')).toBe('tempo-api')
-    expect(new Headers(requests[0]?.init?.headers).get('x-api-key')).toBe('layerzero-api-key')
-    expect(jsonRequestBody(requests[0])).toEqual({
-      amount: '1000000',
-      dstChainKey: 'tempo',
-      dstTokenAddress: candidate.destinationToken.address,
-      dstWalletAddress: '0x1111111111111111111111111111111111111111',
-      options: { amountType: 'EXACT_SRC_AMOUNT' },
-      srcChainKey: 'base',
-      srcTokenAddress: candidate.sourceToken.address,
-      srcWalletAddress: '0x1111111111111111111111111111111111111111',
-    })
-    expect(result).toEqual({
-      expiresAt: '2026-01-01T00:01:00.000Z',
-      destinationAmountMin: '999100',
-      destinationAmount: '999600',
-      quality: {
-        estimatedSeconds: 259,
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'stargate:value-transfer-v1:bus',
-        tier: 'liquid',
-      },
-      sampledAt: '2026-01-01T00:00:00.000Z',
-      status: 'available',
-    })
-  })
-
-  test('skips expired Stargate alternatives', async () => {
-    const candidate = quoteCandidate('stargate')
-    const response = stargateQuotes(candidate)
-    response.quotes[2]!.expiresAt = '2026-01-01T00:00:00.000Z'
-    const provider = Stargate.stargate({
-      apiKey: 'layerzero-api-key',
-      fetch: recordingFetch([], async () => jsonResponse(response)),
-      now,
-      userAddress: '0x1111111111111111111111111111111111111111',
-    })
-
-    await expect(
-      provider.getQuote(getQuoteInput(candidate), new AbortController().signal),
-    ).resolves.toMatchObject({
-      destinationAmountMin: '999000',
-      destinationAmount: '999500',
-      quality: {
-        sourceDetail: 'stargate:value-transfer-v1:taxi',
-        tier: 'liquid',
-      },
-      status: 'available',
-    })
-  })
-
   test('exposes Base and Ethereum Stargate quote candidates', () => {
     expect(
       ['base', 'ethereum'].map((sourceChain) => quoteCandidate('stargate', { sourceChain }).id),
     ).toEqual(['base-usdc-tempo-usdce-stargate', 'ethereum-usdc-tempo-usdce-stargate'])
   })
 
-  test('maps responses without Stargate routes to unavailable quote results', async () => {
-    const candidate = quoteCandidate('stargate')
-    const response = stargateQuotes(candidate)
-    response.quotes = response.quotes.filter((quote) => quote.routeSteps[0]?.type === 'CCTP')
-    const provider = Stargate.stargate({
-      apiKey: 'layerzero-api-key',
-      fetch: recordingFetch([], async () => jsonResponse(response)),
-      now,
-      userAddress: '0x1111111111111111111111111111111111111111',
-    })
-
-    await expect(
-      provider.getQuote(getQuoteInput(candidate), new AbortController().signal),
-    ).resolves.toMatchObject({
-      quality: {
-        sourceDetail: 'stargate:value-transfer-v1:NO_STARGATE_ROUTE',
-        tier: 'unavailable',
-      },
-      status: 'unavailable',
-    })
-  })
-
-  test('rejects malformed Stargate quotes', async () => {
-    const candidate = quoteCandidate('stargate')
-    const response = stargateQuotes(candidate)
-    response.quotes[2]!.srcAmount = '1'
-    const provider = Stargate.stargate({
-      apiKey: 'layerzero-api-key',
-      fetch: recordingFetch([], async () => jsonResponse(response)),
-      now,
-      userAddress: '0x1111111111111111111111111111111111111111',
-    })
-
-    await expect(
-      provider.getQuote(getQuoteInput(candidate), new AbortController().signal),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingProvider.ProviderPayloadError]`)
-  })
-
-  test('rejects invalid Stargate configuration', () => {
-    expect(() =>
-      Stargate.stargate({
-        apiKey: '',
-        userAddress: '0x1111111111111111111111111111111111111111',
-      }),
-    ).toThrowErrorMatchingInlineSnapshot(`[FundingProvider.ProviderConfigurationError]`)
-  })
-
   test('maps successful Symbiosis quotes to available quote results', async () => {
     const requests: RecordedRequest[] = []
     const candidate = quoteCandidate('symbiosis')
@@ -1086,29 +969,17 @@ describe('funding providers', () => {
     })
   })
 
-  test('returns bounded Stargate failure diagnostics', async () => {
-    const candidate = quoteCandidate('stargate')
-    const provider = Stargate.stargate({
-      apiKey: 'layerzero-api-key',
-      fetch: recordingFetch([], async () => jsonResponse({ message: 'Unauthorized' }, 401)),
-      now,
-      userAddress: '0x1111111111111111111111111111111111111111',
-    })
-    const cause = await provider
-      .getQuote(getQuoteInput(candidate), new AbortController().signal)
-      .catch((error: unknown) => error)
-
+  test('returns bounded Stargate failure diagnostics', () => {
     expect(
       FundingProvider.failure({
-        cause,
+        cause: new TypeError('network failure'),
         operation: 'getQuote',
         provider: getProvider('stargate'),
       }),
     ).toEqual({
-      failure: 'http',
+      failure: 'network',
       id: 'stargate',
       operation: 'getQuote',
-      status: 401,
     })
   })
 
@@ -1210,40 +1081,6 @@ function squidQuote(candidate: FundingProvider.getQuote.Parameters['candidate'])
   }
 }
 
-function stargateQuotes(candidate: FundingProvider.getQuote.Parameters['candidate']) {
-  return {
-    error: null,
-    quotes: [
-      {
-        dstAmount: '999900',
-        dstAmountMin: '999800',
-        duration: { estimated: '10000' },
-        id: 'quote-cctp',
-        routeSteps: [{ srcChainKey: 'base', type: 'CCTP' }],
-        srcAmount: candidate.sourceAmount.amount,
-      },
-      {
-        dstAmount: '999500',
-        dstAmountMin: '999000',
-        duration: { estimated: '27600' },
-        expiresAt: '2026-01-01T00:01:00.000Z',
-        id: 'quote-stargate-taxi',
-        routeSteps: [{ srcChainKey: 'base', type: 'STARGATE_V2_TAXI' }],
-        srcAmount: candidate.sourceAmount.amount,
-      },
-      {
-        dstAmount: '999600',
-        dstAmountMin: '999100',
-        duration: { estimated: '258899.99999999997' },
-        expiresAt: '2026-01-01T00:01:00.000Z',
-        id: 'quote-stargate-bus',
-        routeSteps: [{ srcChainKey: 'base', type: 'STARGATE_V2_BUS' }],
-        srcAmount: candidate.sourceAmount.amount,
-      },
-    ],
-  }
-}
-
 function symbiosisQuote(candidate: FundingProvider.getQuote.Parameters['candidate']) {
   const source =
     candidate.sourceChain.kind === 'tron'

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

@@ -147,8 +147,8 @@ describe.skipIf(!apiKey)('relay.prepareTransfer (live)', () => {
       expect(call.data).toMatch(/^0x[0-9a-fA-F]*$/)
       expect(call.value).toBe('0x0')
     }
-    expect(result.correlation.requestId).toMatch(/^0x[0-9a-f]{64}$/)
-    expect(result.correlation.checkEndpoint).toContain('/intents/status/v3')
+    expect(result.correlation?.requestId).toMatch(/^0x[0-9a-f]{64}$/)
+    expect(result.correlation?.checkEndpoint).toContain('/intents/status/v3')
     expect(BigInt(result.destinationAmount) > 0n).toBe(true)
     expect(BigInt(result.destinationAmountMin) > 0n).toBe(true)
     expect(BigInt(result.destinationAmountMin) <= BigInt(result.destinationAmount)).toBe(true)

package/src/internal/funding/providers/relay.ts

@@ -1,5 +1,4 @@
-import { AbiEvent, AbiFunction, Address, Base58, Bytes, Hash, Hex, RpcTransport } from 'ox'
-import { createClient, custom, fallback } from 'viem'
+import { AbiEvent, AbiFunction, Address, Base58, Bytes, Hash, Hex } from 'ox'
 import { getBlockNumber, getLogs, getTransaction, getTransactionReceipt } from 'viem/actions'
 import * as z from 'zod/mini'
 
@@ -820,7 +819,7 @@ function createDepositAddressObserver(
     const stored = schema.DeliveryObservation.safeParse(parameters.providerState)
     const sourceObservation = await (async () => {
       if (stored.success) return stored.data.relay
-      const sourceClient = jsonRpcClient({ fetch: options.fetch, urls: sourceUrls })
+      const sourceClient = Viem.createEvmClient({ fetch: options.fetch, urls: sourceUrls })
       const sourceReceipt = await getTransactionReceipt(sourceClient, {
         hash: parameters.source.transactionHash as Hex.Hex,
       })
@@ -868,7 +867,7 @@ function createDepositAddressObserver(
     })()
     if (!sourceObservation) return { type: 'pending' }
 
-    const destinationClient = jsonRpcClient({ fetch: options.fetch, urls: destinationUrls })
+    const destinationClient = Viem.createEvmClient({ fetch: options.fetch, urls: destinationUrls })
     const destinationHead = await getBlockNumber(destinationClient, { cacheTime: 0 })
     const destinationLogs = await getLogs(destinationClient, {
       address: parameters.destinationToken.address as Address.Address,
@@ -1001,17 +1000,6 @@ function decodeEvent<const event extends AbiEvent.AbiEvent>(
   }
 }
 
-function jsonRpcClient(options: { fetch: FundingProvider.Fetch; urls: readonly string[] }) {
-  return createClient({
-    transport: fallback(
-      options.urls.map((url) => {
-        const transport = RpcTransport.fromHttp(url, { fetchFn: options.fetch })
-        return custom(transport, { retryCount: 0 })
-      }),
-    ),
-  })
-}
-
 function minimum(left: bigint, right: bigint): bigint {
   return left < right ? left : right
 }

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

@@ -0,0 +1,328 @@
+import { AbiFunction, Hex } from 'ox'
+import { base } from 'viem/chains'
+import { tempoMainnet } from 'viem/tempo/chains'
+
+import * as Anvil from '../../../../test/Anvil.js'
+
+import type * as Action from '../Action.js'
+import type * as Catalog from '../Catalog.js'
+import * as FundingChain from '../Chain.js'
+import * as FundingProvider from '../Provider.js'
+import * as Stargate from './stargate.js'
+
+const amount = 1_000_000n
+const destinationPool = '0x8c76e2f6c5ceda9aa7772e7eff30280226c44392'
+const destinationToken = '0x20C000000000000000000000b9537d11c60E8b50'
+const nativeFee = 10_000n
+const otherAddress = '0x9999999999999999999999999999999999999999'
+const pool = '0x27a16dc786820B16E5c9028b75B99F6f604b5d26'
+const recipient = '0x1111111111111111111111111111111111111111'
+const sender = '0x2222222222222222222222222222222222222222'
+const sourceToken = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
+const sourceTransactionHash = '0xfd71359adf5095f2ab512a19e0a2df6c8cc0db14ac8a52286d61287daabdccd4'
+const validAfter = '2020-01-01T00:00:00.000Z'
+const destinationTransactionHash =
+  '0x3dfaba0a78b8f4bc09e55e05211c8120729e7b6879efe32613883befbca666da'
+const guid = '0x5549d117c8b23f0ecdf05c2604ed989cf0034f378707bd81319e93834f2f85f2'
+
+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),
+      verifySourceTransaction: 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: {
+          destinationPoolAddress: destinationPool,
+          poolAddress: otherAddress,
+          sourceEid: 30_184,
+        },
+      }),
+    ).toThrowError(FundingProvider.ProviderPayloadError)
+  })
+})
+
+describe.skipIf(!Anvil.available)('source and destination evidence', () => {
+  const bridgedAmount = '200000'
+  const bridgedRecipient = '0x7212623e4cff9ad010d28aa065fad2bf58578783'
+  const bridgedSender = '0x52b650a62e384f68880d0a1dc2b84dfed47d5660'
+  const configuration = {
+    destinationPoolAddress: destinationPool,
+    poolAddress: pool,
+    sourceEid: 30_184,
+  }
+  let destinationChain: FundingChain.Chain
+  let destination: Anvil.start.ReturnType
+  let sourceChain: FundingChain.Chain
+  let source: Anvil.start.ReturnType
+
+  beforeAll(async () => {
+    ;[destination, source] = await Promise.all([
+      Anvil.start({ chain: tempoMainnet, forkUrl: tempoMainnet.rpcUrls.default.http[0]! }),
+      Anvil.start({ chain: base, forkUrl: base.rpcUrls.default.http[0]! }),
+    ])
+    destinationChain = FundingChain.from({
+      id: 'eip155:4217',
+      name: 'Tempo',
+      rpcUrls: [destination.rpcUrl],
+      slug: 'tempo',
+    })
+    sourceChain = FundingChain.from({
+      id: 'eip155:8453',
+      name: 'Base',
+      rpcUrls: [source.rpcUrl],
+      slug: 'base',
+    })
+  })
+
+  afterAll(async () => {
+    await Promise.all([destination?.stop(), source?.stop()])
+  })
+
+  test('verifies a direct Base Stargate send and its LayerZero GUID', async () => {
+    const receipt = await source.client.getTransactionReceipt({ hash: sourceTransactionHash })
+    await expect(
+      Stargate.verifySourceTransaction({
+        configuration,
+        destinationTokenAddress: destinationToken,
+        recipient: bridgedRecipient,
+        sender: bridgedSender,
+        sourceAmount: bridgedAmount,
+        sourceChain,
+        sourceTokenAddress: sourceToken,
+        transactionHash: sourceTransactionHash,
+        validAfter,
+      }),
+    ).resolves.toEqual({
+      guid,
+      sourceBlock: { hash: receipt.blockHash, number: receipt.blockNumber },
+      sourceEid: 30_184,
+      type: 'verified',
+    })
+  })
+
+  test('keeps missing transactions pending and rejects mismatched terms', async () => {
+    const options = {
+      configuration,
+      destinationTokenAddress: destinationToken,
+      recipient: bridgedRecipient,
+      sender: bridgedSender,
+      sourceAmount: bridgedAmount,
+      sourceChain,
+      sourceTokenAddress: sourceToken,
+      transactionHash: sourceTransactionHash,
+      validAfter,
+    }
+    await expect(
+      Stargate.verifySourceTransaction({
+        ...options,
+        transactionHash: `0x${'99'.repeat(32)}`,
+      }),
+    ).resolves.toEqual({ type: 'pending' })
+    await expect(
+      Stargate.verifySourceTransaction({ ...options, recipient: otherAddress }),
+    ).resolves.toEqual({ type: 'invalid' })
+    await expect(
+      Stargate.verifySourceTransaction({ ...options, validAfter: '2099-01-01T00:00:00.000Z' }),
+    ).resolves.toEqual({ type: 'invalid' })
+  })
+
+  test('rejects reverted and malformed source transactions', async () => {
+    const account = Anvil.getAccount(1)
+    const reverted = await source.client.sendTransactionSync({
+      account,
+      data: '0xdeadbeef',
+      gas: 100_000n,
+      to: pool,
+    })
+    const malformed = await source.client.sendTransactionSync({
+      account,
+      data: '0xdeadbeef',
+      gas: 100_000n,
+      to: account.address,
+    })
+    const options = {
+      configuration,
+      destinationTokenAddress: destinationToken,
+      recipient: bridgedRecipient,
+      sender: account.address,
+      sourceAmount: bridgedAmount,
+      sourceChain,
+      sourceTokenAddress: sourceToken,
+      validAfter,
+    }
+    await expect(
+      Stargate.verifySourceTransaction({
+        ...options,
+        transactionHash: reverted.transactionHash,
+      }),
+    ).resolves.toEqual({ type: 'invalid' })
+    await expect(
+      Stargate.verifySourceTransaction({
+        ...options,
+        transactionHash: malformed.transactionHash,
+      }),
+    ).resolves.toEqual({ type: 'invalid' })
+  })
+
+  test('discovers and verifies the exact Tempo USDC.e delivery', async () => {
+    const receipt = await destination.client.getTransactionReceipt({
+      hash: destinationTransactionHash,
+    })
+    await expect(
+      Stargate.verifyDestinationDelivery({
+        configuration,
+        destinationAmount: bridgedAmount,
+        destinationBlockNumber: receipt.blockNumber.toString(),
+        destinationChain,
+        destinationTokenAddress: destinationToken,
+        guid,
+        recipient: bridgedRecipient,
+        sourceChainId: 'eip155:8453',
+        sourceTokenAddress: sourceToken,
+      }),
+    ).resolves.toEqual({ transactionHash: destinationTransactionHash, type: 'verified' })
+  })
+})
+
+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 ?? {
+      destinationPoolAddress: destinationPool,
+      poolAddress: pool,
+      sourceEid: 30_184,
+    },
+    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
+  }
+}