tapimo 0.7.1 → 0.7.2

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

@@ -0,0 +1,151 @@
+import { Address } from 'ox'
+import * as z from 'zod/mini'
+
+import * as FundingChain from '../Chain.js'
+import * as FundingProvider from '../Provider.js'
+
+const defaultBaseUrl = 'https://v2.api.squidrouter.com/v2'
+const defaultFetch: FundingProvider.Fetch = (input, init) => globalThis.fetch(input, init)
+
+namespace schema {
+  const IntegerString = z.string().check(z.regex(/^\d+$/))
+
+  const Token = z.object({
+    address: z.string(),
+    chainId: z.union([z.string(), z.number().check(z.int(), z.nonnegative())]),
+    decimals: z.number().check(z.int(), z.nonnegative()),
+  })
+
+  export const Quote = z.object({
+    route: z.object({
+      estimate: z.object({
+        estimatedRouteDuration: z.number().check(z.nonnegative()),
+        fromAmount: IntegerString,
+        fromToken: Token,
+        toAmount: IntegerString,
+        toAmountMin: IntegerString,
+        toToken: Token,
+      }),
+    }),
+  })
+
+  export const AmountUnavailable = z.object({
+    message: z.literal('Please increase the swap amount and try again.'),
+    type: z.literal('BAD_REQUEST'),
+  })
+}
+
+/** Creates a Squid funding provider backed by `/v2/route`. */
+export function squid(options: squid.Options) {
+  if (options.integratorId.length === 0) throw new FundingProvider.ProviderConfigurationError()
+  if (!Address.validate(options.userAddress, { strict: false }))
+    throw new FundingProvider.ProviderConfigurationError()
+
+  const endpoint = new URL(options.baseUrl ?? defaultBaseUrl)
+  endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/route`
+  const fetch = options.fetch ?? defaultFetch
+  const now = options.now ?? (() => new Date())
+
+  return FundingProvider.from({
+    id: 'squid',
+    name: 'Squid',
+    async getQuote({ candidate, route }, signal) {
+      const destinationChainId = FundingChain.eip155Id(route.destination.chain)
+      const sourceChainId = FundingChain.eip155Id(route.source.chain)
+      try {
+        const quote = await FundingProvider.requestJson(endpoint, {
+          body: {
+            fromAddress: options.userAddress,
+            fromAmount: candidate.sourceAmount.amount,
+            fromChain: sourceChainId,
+            fromToken: candidate.sourceToken.address,
+            quoteOnly: true,
+            // V1 quotes use a fixed 1% tolerance; callers cannot customize execution policy.
+            slippage: 1,
+            toAddress: options.userAddress,
+            toChain: destinationChainId,
+            toToken: candidate.destinationToken.address,
+          },
+          fetch,
+          headers: { 'x-integrator-id': options.integratorId },
+          method: 'POST',
+          signal,
+        })
+        const parsed = schema.Quote.safeParse(quote)
+        if (!parsed.success) throw new FundingProvider.ProviderPayloadError()
+        const response = parsed.data.route.estimate
+        if (
+          response.fromAmount !== candidate.sourceAmount.amount ||
+          !matchesToken(response.fromToken, sourceChainId, candidate.sourceToken) ||
+          !matchesToken(response.toToken, destinationChainId, candidate.destinationToken) ||
+          BigInt(response.toAmount) <= 0n ||
+          BigInt(response.toAmountMin) <= 0n ||
+          BigInt(response.toAmountMin) > BigInt(response.toAmount)
+        )
+          throw new FundingProvider.ProviderPayloadError()
+
+        return {
+          destinationAmountMin: response.toAmountMin,
+          destinationAmount: response.toAmount,
+          quality: {
+            estimatedSeconds: Math.ceil(response.estimatedRouteDuration),
+            liquiditySource: 'providerQuote',
+            sourceDetail: 'squid:route-v2',
+            tier: 'liquid',
+          },
+          sampledAt: now().toISOString(),
+          status: 'available',
+        }
+      } catch (cause) {
+        const unavailable =
+          FundingProvider.unavailable(cause, [
+            'NO_ROUTE',
+            'NO_ROUTE_FOUND',
+            'ROUTE_NOT_FOUND',
+            'UNSUPPORTED_ROUTE',
+          ]) ?? amountUnavailable(cause)
+        if (!unavailable) throw cause
+        return FundingProvider.unavailableResult({
+          detail: 'squid:route-v2',
+          message: unavailable,
+          now: now(),
+          source: 'providerQuote',
+        })
+      }
+    },
+  })
+}
+
+export declare namespace squid {
+  /** Squid provider options. */
+  type Options = {
+    /** Override for tests or Squid test environments. */
+    baseUrl?: string | undefined
+    /** Fetch implementation override for tests. */
+    fetch?: FundingProvider.Fetch | undefined
+    /** Squid integrator id sent in the required request header. */
+    integratorId: string
+    /** Clock override for deterministic tests. */
+    now?: (() => Date) | undefined
+    /** Quote wallet address used as the Squid sender and recipient. */
+    userAddress: string
+  }
+}
+
+function amountUnavailable(cause: unknown) {
+  if (!(cause instanceof FundingProvider.ProviderResponseError) || cause.status !== 400)
+    return undefined
+  return schema.AmountUnavailable.safeParse(cause.body).success ? 'AMOUNT_TOO_LOW' : undefined
+}
+
+function matchesToken(
+  token: z.output<typeof schema.Quote>['route']['estimate']['fromToken'],
+  chainId: string,
+  expected: FundingProvider.TokenRef,
+) {
+  return (
+    token.address.toLowerCase() === expected.address.toLowerCase() &&
+    String(token.chainId) === chainId &&
+    token.decimals === expected.decimals
+  )
+}

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

@@ -0,0 +1,221 @@
+import { Address } from 'ox'
+import * as z from 'zod/mini'
+
+import * as Store from '../../Store.js'
+import * as FundingChain from '../Chain.js'
+import * as FundingProvider from '../Provider.js'
+import type * as FundingToken from '../Token.js'
+
+const defaultBaseUrl = 'https://api.symbiosis.finance/crosschain'
+const defaultFetch: FundingProvider.Fetch = (input, init) => globalThis.fetch(input, init)
+// Keep one upstream slot free for deployment smoke tests and operational probes.
+const rateLimit = 4
+const rateLimitWindowMs = 1_000
+const tronChainId = 728_126_428
+const tronUsdtAddress = '0xa614f803b6fd780986a42c78ec9c7f77e6ded13c'
+
+namespace schema {
+  const IntegerString = z.string().check(z.regex(/^\d+$/))
+
+  export const Token = z.object({
+    address: z.string(),
+    chainId: z.number().check(z.int(), z.nonnegative()),
+    decimals: z.number().check(z.int(), z.nonnegative()),
+  })
+
+  const TokenAmount = z.extend(Token, { amount: IntegerString })
+
+  export const Quote = z.object({
+    estimatedTime: z.optional(z.number().check(z.nonnegative())),
+    kind: z.union([z.literal('bridge'), z.literal('crosschain-swap'), z.literal('intent-swap')]),
+    routes: z
+      .array(
+        z.object({
+          tokens: z.array(Token).check(z.minLength(1)),
+        }),
+      )
+      .check(z.minLength(1)),
+    tokenAmountOut: TokenAmount,
+    tokenAmountOutMin: TokenAmount,
+    tx: z.object({ chainId: z.number().check(z.int(), z.nonnegative()) }),
+    type: z.union([z.literal('evm'), z.literal('tron')]),
+  })
+
+  export const AmountUnavailable = z.object({
+    message: z.literal('Amount is too low to cover fees'),
+  })
+}
+
+/** Creates a Symbiosis funding provider backed by `/v2/quote`. */
+export function symbiosis(options: symbiosis.Options) {
+  if (!Address.validate(options.userAddress, { strict: false }))
+    throw new FundingProvider.ProviderConfigurationError()
+
+  const endpoint = new URL(options.baseUrl ?? defaultBaseUrl)
+  endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/v2/quote`
+  const fetch = options.fetch ?? defaultFetch
+  const now = options.now ?? (() => new Date())
+  const rateLimitStore = options.rateLimitStore ?? Store.memory()
+
+  return FundingProvider.from({
+    id: 'symbiosis',
+    name: 'Symbiosis',
+    async getQuote({ candidate, route }, signal) {
+      const destinationChainId = chainId(route.destination.chain)
+      const sourceChainId = chainId(route.source.chain)
+      const sourceTokenAddress = tokenAddress(route.source)
+      try {
+        await consumeQuota(rateLimitStore, now())
+        const quote = await FundingProvider.requestJson(endpoint, {
+          body: {
+            from: options.userAddress,
+            slippage: 100,
+            to: options.userAddress,
+            tokenAmountIn: {
+              address: sourceTokenAddress,
+              amount: candidate.sourceAmount.amount,
+              chainId: sourceChainId,
+              decimals: candidate.sourceToken.decimals,
+              symbol: candidate.sourceToken.symbol,
+            },
+            tokenOut: {
+              address: candidate.destinationToken.address,
+              chainId: destinationChainId,
+              decimals: candidate.destinationToken.decimals,
+              symbol: candidate.destinationToken.symbol,
+            },
+          },
+          fetch,
+          headers: { 'x-partner-id': 'tempo' },
+          method: 'POST',
+          signal,
+        })
+        const parsed = schema.Quote.safeParse(quote)
+        if (!parsed.success) throw new FundingProvider.ProviderPayloadError()
+        const response = parsed.data
+        const firstToken = response.routes[0]!.tokens[0]!
+        const lastRoute = response.routes[response.routes.length - 1]!
+        const lastToken = lastRoute.tokens[lastRoute.tokens.length - 1]!
+        if (
+          response.tx.chainId !== sourceChainId ||
+          response.type !== candidate.sourceChain.kind ||
+          !matchesToken(firstToken, {
+            address: sourceTokenAddress,
+            chainId: sourceChainId,
+            decimals: candidate.sourceToken.decimals,
+          }) ||
+          !matchesToken(lastToken, {
+            address: candidate.destinationToken.address,
+            chainId: destinationChainId,
+            decimals: candidate.destinationToken.decimals,
+          }) ||
+          !matchesToken(response.tokenAmountOut, {
+            address: candidate.destinationToken.address,
+            chainId: destinationChainId,
+            decimals: candidate.destinationToken.decimals,
+          }) ||
+          !matchesToken(response.tokenAmountOutMin, {
+            address: candidate.destinationToken.address,
+            chainId: destinationChainId,
+            decimals: candidate.destinationToken.decimals,
+          }) ||
+          BigInt(response.tokenAmountOut.amount) <= 0n ||
+          BigInt(response.tokenAmountOutMin.amount) <= 0n ||
+          BigInt(response.tokenAmountOutMin.amount) > BigInt(response.tokenAmountOut.amount)
+        )
+          throw new FundingProvider.ProviderPayloadError()
+
+        return {
+          destinationAmountMin: response.tokenAmountOutMin.amount,
+          destinationAmount: response.tokenAmountOut.amount,
+          quality: {
+            ...(response.estimatedTime === undefined
+              ? {}
+              : { estimatedSeconds: Math.ceil(response.estimatedTime) }),
+            liquiditySource: 'providerQuote',
+            sourceDetail: 'symbiosis:quote-v2',
+            tier: 'liquid',
+          },
+          sampledAt: now().toISOString(),
+          status: 'available',
+        }
+      } catch (cause) {
+        const unavailable =
+          FundingProvider.unavailable(cause, [
+            'AMOUNT_TOO_LOW',
+            'NO_ROUTE',
+            'NO_ROUTE_FOUND',
+            'ROUTE_NOT_FOUND',
+            'UNSUPPORTED_ROUTE',
+          ]) ?? amountUnavailable(cause)
+        if (!unavailable) throw cause
+        return FundingProvider.unavailableResult({
+          detail: 'symbiosis:quote-v2',
+          message: unavailable,
+          now: now(),
+          source: 'providerQuote',
+        })
+      }
+    },
+  })
+}
+
+export declare namespace symbiosis {
+  /** Symbiosis provider options. */
+  type Options = {
+    /** Override for tests or Symbiosis test environments. */
+    baseUrl?: string | undefined
+    /** Fetch implementation override for tests. */
+    fetch?: FundingProvider.Fetch | undefined
+    /** Clock override for deterministic tests. */
+    now?: (() => Date) | undefined
+    /** Atomic store used to enforce the provider-wide quote quota. */
+    rateLimitStore?: Store.Store | undefined
+    /** Quote wallet address used as the Symbiosis sender and recipient. */
+    userAddress: string
+  }
+}
+
+async function consumeQuota(store: Store.Store, now: Date) {
+  const time = now.getTime()
+  const bucket = Math.floor(time / rateLimitWindowMs)
+  const count = await Store.increment(store, `funding:symbiosis:quote:${bucket}`, {
+    ttl: rateLimitWindowMs * 2,
+  })
+  if (count > rateLimit) throw new FundingProvider.ProviderRateLimitError()
+}
+
+function amountUnavailable(cause: unknown) {
+  if (!(cause instanceof FundingProvider.ProviderResponseError) || cause.status !== 400)
+    return undefined
+  return schema.AmountUnavailable.safeParse(cause.body).success ? 'AMOUNT_TOO_LOW' : undefined
+}
+
+function chainId(chain: FundingChain.Chain) {
+  if (chain.kind === 'tron') return tronChainId
+  return Number(FundingChain.eip155Id(chain))
+}
+
+function tokenAddress(token: FundingToken.Resolved) {
+  return token.chain.kind === 'tron' ? tronUsdtAddress : token.address
+}
+
+function matchesToken(token: z.output<typeof schema.Token>, options: matchesToken.Options) {
+  return (
+    token.address.toLowerCase() === options.address.toLowerCase() &&
+    token.chainId === options.chainId &&
+    token.decimals === options.decimals
+  )
+}
+
+declare namespace matchesToken {
+  /** Expected provider token identity. */
+  type Options = {
+    /** Provider-specific token address. */
+    address: string
+    /** Provider-specific chain id. */
+    chainId: number
+    /** Token decimal precision. */
+    decimals: number
+  }
+}

package/src/internal/index.test.ts

@@ -7,15 +7,19 @@ test('exports internal modules', () => {
       "Cache",
       "Cursor",
       "EdgeCache",
+      "EarnVaults",
       "Errors",
+      "Exchange",
       "Fees",
-      "FundingQuotes",
+      "Funding",
       "Id",
+      "Idempotency",
       "Log",
       "MetricSink",
       "Mpp",
       "OpenApi",
       "Path",
+      "Provider",
       "RateLimit",
       "Response",
       "RpcSchema",

package/src/internal/index.ts

@@ -2,15 +2,19 @@ export * as Auth from './Auth.js'
 export * as Cache from './Cache.js'
 export * as Cursor from './Cursor.js'
 export * as EdgeCache from './EdgeCache.js'
+export * as EarnVaults from './EarnVaults.js'
 export * as Errors from './Errors.js'
+export * as Exchange from './exchange/index.js'
 export * as Fees from './Fees.js'
-export * as FundingQuotes from './FundingQuotes.js'
+export * as Funding from './funding/index.js'
 export * as Id from './Id.js'
+export * as Idempotency from './Idempotency.js'
 export * as Log from './Log.js'
 export * as MetricSink from './MetricSink.js'
 export * as Mpp from './Mpp.js'
 export * as OpenApi from './OpenApi.js'
 export * as Path from './Path.js'
+export * as Provider from './Provider.js'
 export * as RateLimit from './RateLimit.js'
 export * as Response from './Response.js'
 export * as RpcSchema from './RpcSchema.js'

package/src/internal/webhookDestinations/url.ts

@@ -67,62 +67,66 @@ export function assertDeliverableUrl(input: string): URL {
   if (url.protocol !== 'https:') throw new WebhookDestination.InvalidUrlError('protocol', input)
   if (url.username || url.password)
     throw new WebhookDestination.InvalidUrlError('credentials', input)
-  if (isBlockedHost(url.hostname))
+  if (Hostname.isBlocked(url.hostname))
     throw new WebhookDestination.InvalidUrlError('blocked_host', input)
 
   return url
 }
 
-function isBlockedHost(hostname: string): boolean {
-  // URL hostnames preserve IPv6 brackets and are already lowercased for names.
-  const host = hostname.replace(/^\[|\]$/g, '').toLowerCase()
+namespace Hostname {
+  export function isBlocked(hostname: string): boolean {
+    // URL hostnames preserve IPv6 brackets and are already lowercased for names.
+    const host = hostname.replace(/^\[|\]$/g, '').toLowerCase()
 
-  if (host === 'localhost' || host.endsWith('.localhost')) return true
-  if (host === 'metadata.google.internal') return true
-  if (host.length === 0) return true
+    if (host === 'localhost' || host.endsWith('.localhost')) return true
+    if (host === 'metadata.google.internal') return true
+    if (host.length === 0) return true
 
-  if (isIpv4(host)) return isBlockedIpv4(host)
-  if (host.includes(':')) return isBlockedIpv6(host)
-  return false
-}
+    if (isIpv4(host)) return isBlockedIpv4(host)
+    if (host.includes(':')) return isBlockedIpv6(host)
+    return false
+  }
 
-function isIpv4(host: string): boolean {
-  const parts = host.split('.')
-  return parts.length === 4 && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)
-}
+  function isIpv4(host: string): boolean {
+    const parts = host.split('.')
+    return (
+      parts.length === 4 && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)
+    )
+  }
 
-function isBlockedIpv4(host: string): boolean {
-  const [a, b] = host.split('.').map(Number) as [number, number, number, number]
-  if (a === 0 || a === 10 || a === 127) return true // unspecified, private, loopback
-  if (a === 169 && b === 254) return true // link-local (incl. cloud metadata)
-  if (a === 172 && b >= 16 && b <= 31) return true // private
-  if (a === 192 && b === 168) return true // private
-  if (a === 100 && b >= 64 && b <= 127) return true // carrier-grade NAT
-  return false
-}
+  function isBlockedIpv4(host: string): boolean {
+    const [a, b] = host.split('.').map(Number) as [number, number, number, number]
+    if (a === 0 || a === 10 || a === 127) return true // unspecified, private, loopback
+    if (a === 169 && b === 254) return true // link-local (incl. cloud metadata)
+    if (a === 172 && b >= 16 && b <= 31) return true // private
+    if (a === 192 && b === 168) return true // private
+    if (a === 100 && b >= 64 && b <= 127) return true // carrier-grade NAT
+    return false
+  }
 
-function isBlockedIpv6(host: string): boolean {
-  if (host === '::' || host === '::1') return true // unspecified, loopback
-  if (
-    host.startsWith('fe8') ||
-    host.startsWith('fe9') ||
-    host.startsWith('fea') ||
-    host.startsWith('feb')
-  )
-    return true // link-local fe80::/10
-  if (host.startsWith('fc') || host.startsWith('fd')) return true // unique local fc00::/7
+  function isBlockedIpv6(host: string): boolean {
+    if (host === '::' || host === '::1') return true // unspecified, loopback
+    if (
+      host.startsWith('fe8') ||
+      host.startsWith('fe9') ||
+      host.startsWith('fea') ||
+      host.startsWith('feb')
+    )
+      return true // link-local fe80::/10
+    if (host.startsWith('fc') || host.startsWith('fd')) return true // unique local fc00::/7
 
-  // IPv4-mapped (::ffff:a.b.c.d) — re-check the embedded v4.
-  const dotted = host.match(/::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/)
-  if (dotted?.[1] && isIpv4(dotted[1])) return isBlockedIpv4(dotted[1])
+    // IPv4-mapped (::ffff:a.b.c.d) — re-check the embedded v4.
+    const dotted = host.match(/::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/)
+    if (dotted?.[1] && isIpv4(dotted[1])) return isBlockedIpv4(dotted[1])
 
-  // The URL parser compresses ::ffff:a.b.c.d to two hex groups (e.g. 7f00:1).
-  const hex = host.match(/::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/)
-  if (hex?.[1] && hex[2]) {
-    const high = Number.parseInt(hex[1], 16)
-    const low = Number.parseInt(hex[2], 16)
-    const v4 = `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`
-    return isBlockedIpv4(v4)
+    // The URL parser compresses ::ffff:a.b.c.d to two hex groups (e.g. 7f00:1).
+    const hex = host.match(/::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/)
+    if (hex?.[1] && hex[2]) {
+      const high = Number.parseInt(hex[1], 16)
+      const low = Number.parseInt(hex[2], 16)
+      const ipv4 = `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`
+      return isBlockedIpv4(ipv4)
+    }
+    return false
   }
-  return false
 }

package/src/providers/index.test.ts

@@ -0,0 +1,14 @@
+import * as Providers from './index.js'
+
+test('exports provider factories', () => {
+  expect(Object.keys(Providers)).toMatchInlineSnapshot(`
+    [
+      "across",
+      "relay",
+      "rhino",
+      "squid",
+      "symbiosis",
+      "uniswap",
+    ]
+  `)
+})

package/src/providers/index.ts

@@ -0,0 +1,54 @@
+import * as Uniswap from '../internal/exchange/providers/uniswap.js'
+import * as Across from '../internal/funding/providers/across.js'
+import * as Relay from '../internal/funding/providers/relay.js'
+import * as Rhino from '../internal/funding/providers/rhino.js'
+import * as Squid from '../internal/funding/providers/squid.js'
+import * as Symbiosis from '../internal/funding/providers/symbiosis.js'
+
+/** Creates an Across funding provider. */
+export const across = Across.across
+
+export declare namespace across {
+  /** Across provider configuration. */
+  type Options = Across.across.Options
+}
+
+/** Creates a Relay funding provider. */
+export const relay = Relay.relay
+
+export declare namespace relay {
+  /** Relay provider configuration. */
+  type Options = Relay.relay.Options
+}
+
+/** Creates a Rhino funding provider. */
+export const rhino = Rhino.rhino
+
+export declare namespace rhino {
+  /** Rhino provider configuration. */
+  type Options = Rhino.rhino.Options
+}
+
+/** Creates a Squid funding provider. */
+export const squid = Squid.squid
+
+export declare namespace squid {
+  /** Squid provider configuration. */
+  type Options = Squid.squid.Options
+}
+
+/** Creates a Symbiosis funding provider. */
+export const symbiosis = Symbiosis.symbiosis
+
+export declare namespace symbiosis {
+  /** Symbiosis provider configuration. */
+  type Options = Symbiosis.symbiosis.Options
+}
+
+/** Creates a Uniswap exchange provider. */
+export const uniswap = Uniswap.uniswap
+
+export declare namespace uniswap {
+  /** Uniswap provider configuration. */
+  type Options = Uniswap.uniswap.Options
+}