accounts 0.8.6 → 0.8.8

package/dist/server/internal/tokenlist.d.ts

@@ -0,0 +1,53 @@
+import type { Address } from 'viem';
+import type * as Kv from '../Kv.js';
+/** A single tokenlist entry. */
+export type Token = {
+    /** Token address. */
+    address: Address;
+    /** Token decimals. */
+    decimals: number;
+    /** Token logo URI. */
+    logoUri?: string | undefined;
+    /** Token name. */
+    name: string;
+    /** Token symbol. */
+    symbol: string;
+};
+/**
+ * Fetches the verified tokenlist for `chainId`. Reads through `kv` so
+ * concurrent callers in the same scope share a single upstream request,
+ * and so independent handlers (e.g. `Handler.relay` + `Handler.exchange`)
+ * reuse the same KV cache key.
+ *
+ * Returns an empty list on any non-OK response — callers should fall back
+ * to chain-supplied behavior rather than treating an empty list as fatal.
+ *
+ * @param chainId - Chain id to fetch the tokenlist for.
+ * @param kv - Kv used to cache responses across requests.
+ * @param options - Options.
+ * @returns Tokens for the chain.
+ */
+export declare function fetch(chainId: number, kv: Kv.Kv, options?: fetch.Options): Promise<readonly Token[]>;
+export declare namespace fetch {
+    /** Options for `fetch()`. */
+    type Options = {
+        /**
+         * Base URL of the tokenlist service.
+         * @default 'https://tokenlist.tempo.xyz'
+         */
+        baseUrl?: string | undefined;
+        /**
+         * TTL in seconds for the cached response.
+         * @default 600 (10 minutes)
+         */
+        cacheTtl?: number | undefined;
+        /**
+         * Override resolver. When provided, the cache hit path is unchanged but
+         * cache misses route through this function instead of fetching the
+         * default `tokenlist.tempo.xyz` URL. Useful for tests or for vendoring
+         * a curated list per app.
+         */
+        resolver?: ((chainId: number) => readonly Token[] | Promise<readonly Token[]>) | undefined;
+    };
+}
+//# sourceMappingURL=tokenlist.d.ts.map

package/dist/server/internal/tokenlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenlist.d.ts","sourceRoot":"","sources":["../../../src/server/internal/tokenlist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,KAAK,KAAK,EAAE,MAAM,UAAU,CAAA;AASnC,gCAAgC;AAChC,MAAM,MAAM,KAAK,GAAG;IAClB,qBAAqB;IACrB,OAAO,EAAE,OAAO,CAAA;IAChB,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,kBAAkB;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,oBAAoB;IACpB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,KAAK,CACzB,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,EAAE,CAAC,EAAE,EACT,OAAO,GAAE,KAAK,CAAC,OAAY,GAC1B,OAAO,CAAC,SAAS,KAAK,EAAE,CAAC,CAQ3B;AAED,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B,6BAA6B;IAC7B,KAAK,OAAO,GAAG;QACb;;;WAGG;QACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC5B;;;WAGG;QACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC7B;;;;;WAKG;QACH,QAAQ,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,SAAS,KAAK,EAAE,GAAG,OAAO,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;KAC3F,CAAA;CACF"}

package/dist/server/internal/tokenlist.js

@@ -0,0 +1,38 @@
+import { cached } from './kv.js';
+/** Default cache TTL in seconds (10 minutes) for tokenlist responses. */
+const defaultCacheTtl = 10 * 60;
+/** Default base URL for the verified tokenlist service. */
+const defaultBaseUrl = 'https://tokenlist.tempo.xyz';
+/**
+ * Fetches the verified tokenlist for `chainId`. Reads through `kv` so
+ * concurrent callers in the same scope share a single upstream request,
+ * and so independent handlers (e.g. `Handler.relay` + `Handler.exchange`)
+ * reuse the same KV cache key.
+ *
+ * Returns an empty list on any non-OK response — callers should fall back
+ * to chain-supplied behavior rather than treating an empty list as fatal.
+ *
+ * @param chainId - Chain id to fetch the tokenlist for.
+ * @param kv - Kv used to cache responses across requests.
+ * @param options - Options.
+ * @returns Tokens for the chain.
+ */
+export async function fetch(chainId, kv, options = {}) {
+    const { baseUrl = defaultBaseUrl, cacheTtl = defaultCacheTtl, resolver } = options;
+    return cached(kv, `tokenlist:${chainId}`, async () => (resolver ? resolver(chainId) : fetchUncached(chainId, baseUrl)), { ttl: cacheTtl });
+}
+/**
+ * Default fetcher — resolves the verified tokenlist for `chainId` directly
+ * from `tokenlist.tempo.xyz`. Returns an empty list on any non-OK response.
+ */
+async function fetchUncached(chainId, baseUrl) {
+    const response = await globalThis.fetch(`${baseUrl}/list/${chainId}`);
+    if (!response.ok)
+        return [];
+    const data = (await response.json());
+    return data.tokens.map(({ logoURI, ...token }) => ({
+        ...token,
+        logoUri: token.logoUri ?? logoURI,
+    }));
+}
+//# sourceMappingURL=tokenlist.js.map

package/dist/server/internal/tokenlist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenlist.js","sourceRoot":"","sources":["../../../src/server/internal/tokenlist.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAEhC,yEAAyE;AACzE,MAAM,eAAe,GAAG,EAAE,GAAG,EAAE,CAAA;AAE/B,2DAA2D;AAC3D,MAAM,cAAc,GAAG,6BAA6B,CAAA;AAgBpD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,KAAK,CACzB,OAAe,EACf,EAAS,EACT,UAAyB,EAAE;IAE3B,MAAM,EAAE,OAAO,GAAG,cAAc,EAAE,QAAQ,GAAG,eAAe,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAA;IAClF,OAAO,MAAM,CACX,EAAE,EACF,aAAa,OAAO,EAAE,EACtB,KAAK,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EAC5E,EAAE,GAAG,EAAE,QAAQ,EAAE,CAClB,CAAA;AACH,CAAC;AAyBD;;;GAGG;AACH,KAAK,UAAU,aAAa,CAAC,OAAe,EAAE,OAAe;IAC3D,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,KAAK,CAAC,GAAG,OAAO,SAAS,OAAO,EAAE,CAAC,CAAA;IACrE,IAAI,CAAC,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE,CAAA;IAC3B,MAAM,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAElC,CAAA;IACD,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;QACjD,GAAG,KAAK;QACR,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,OAAO;KAClC,CAAC,CAAC,CAAA;AACL,CAAC"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "accounts",
   "description": "Tempo Accounts SDK",
   "type": "module",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "dependencies": {
     "hono": "^4.12.14",
     "idb-keyval": "^6.2.2",

package/src/core/Storage.ts

@@ -37,7 +37,7 @@ export function combine(...storages: readonly Storage[]): Storage {
   return {
     async getItem<value>(name: string) {
       const results = await Promise.allSettled(storages.map((x) => x.getItem<value>(name)))
-      const result = results.find((x) => x.status === 'fulfilled' && x.value !== null)
+      const result = results.find((x) => x.status === 'fulfilled' && x.value != null)
       if (result?.status !== 'fulfilled') return null
       return result.value as value
     },

package/src/core/zod/rpc.ts

@@ -551,6 +551,8 @@ export namespace wallet_send {
     method: z.literal('wallet_send'),
     params: z.optional(z.readonly(z.tuple([parameters]))),
     returns: z.object({
+      /** Chain id the send is to. */
+      chainId: u.number(),
       /** Receipt of the submitted send. */
       receipt,
     }),

package/src/server/internal/handlers/exchange.ts

@@ -19,6 +19,7 @@ import { type Handler, from } from '../../Handler.js'
 import * as Kv from '../../Kv.js'
 import * as Hono from '../hono.js'
 import { cached } from '../kv.js'
+import * as Tokenlist from '../tokenlist.js'
 
 /** Default cache TTL in seconds (10 minutes). */
 const defaultCacheTtl = 10 * 60
@@ -144,11 +145,14 @@ export function exchange<const path extends string = '/exchange'>(
     kv = Kv.memory(),
     onRequest,
     path = '/exchange' as path,
-    resolveTokens = defaultResolveTokens,
+    resolveTokens,
     transports = {},
     ...rest
   } = options
 
+  const getTokens = (chainId: number) =>
+    Tokenlist.fetch(chainId, kv, { cacheTtl, resolver: resolveTokens })
+
   const clients = new Map<number, Client>()
   for (const chain of chains) {
     const transport = transports[chain.id] ?? http()
@@ -170,12 +174,7 @@ export function exchange<const path extends string = '/exchange'>(
         const chain = chains.find((c) => c.id === chainId)
         if (!chain) throw new Error(`Chain ${chainId} is not supported.`)
 
-        const tokens = await cached(
-          kv,
-          `tokenlist:${chain.id}`,
-          async () => resolveTokens(chain.id),
-          { ttl: cacheTtl },
-        )
+        const tokens = await getTokens(chain.id)
 
         // Cache for `cacheTtl` and allow stale-while-revalidate for an
         // additional full TTL window so CDNs/browsers can serve immediately
@@ -202,12 +201,7 @@ export function exchange<const path extends string = '/exchange'>(
         const client = clients.get(chain.id)!
 
         // Resolve `token` and `pairToken` to addresses + metadata in parallel.
-        const tokens = await cached(
-          kv,
-          `tokenlist:${chain.id}`,
-          async () => resolveTokens(chain.id),
-          { ttl: cacheTtl },
-        )
+        const tokens = await getTokens(chain.id)
         const [tokenInfo, pairTokenInfo] = await Promise.all([
           resolveToken(client, { kv, ref: token, tokens }),
           resolveToken(client, { kv, ref: pairToken, tokens }),
@@ -478,21 +472,3 @@ function applySlippage(amount: bigint, slippage: number, dir: 'up' | 'down') {
 function toCall(call: { data: Hex.Hex; to: Address }) {
   return { data: call.data, to: call.to }
 }
-
-/**
- * Default `resolveTokens` implementation. Fetches the verified token list for
- * `chainId` from `https://tokenlist.tempo.xyz/list/:chainId`. Returns an empty
- * list on any non-OK response.
- */
-async function defaultResolveTokens(chainId: number): Promise<readonly Token[]> {
-  // TODO: deprecate tokenlist.tempo.xyz when TIP-1026 enshrined.
-  const response = await fetch(`https://tokenlist.tempo.xyz/list/${chainId}`)
-  if (!response.ok) return []
-  const data = (await response.json()) as {
-    tokens: readonly (Token & { logoURI?: string })[]
-  }
-  return data.tokens.map(({ logoURI, ...token }) => ({
-    ...token,
-    logoUri: token.logoUri ?? logoURI,
-  }))
-}

package/src/server/internal/handlers/relay.test.ts

@@ -14,6 +14,18 @@ const userAccount = accounts[9]!
 const feePayerAccount = accounts[0]!
 const recipient = accounts[7]!
 
+/**
+ * Tokens the relay handler probes for fee-token resolution. The default
+ * `resolveTokens` fetches `tokenlist.tempo.xyz`, which doesn't know about
+ * the localnet chain — so tests inject this list explicitly.
+ */
+const localnetTokens = [
+  { address: '0x20c0000000000000000000000000000000000000', decimals: 6, name: 'pathUSD', symbol: 'pathUSD' },
+  { address: '0x20c0000000000000000000000000000000000001', decimals: 6, name: 'alphaUSD', symbol: 'alphaUSD' },
+  { address: '0x20c0000000000000000000000000000000000002', decimals: 6, name: 'betaUSD', symbol: 'betaUSD' },
+  { address: '0x20c0000000000000000000000000000000000003', decimals: 6, name: 'thetaUSD', symbol: 'thetaUSD' },
+] as const
+
 /** Case-insensitive lookup into balanceDiffs keyed by address. */
 function findDiffs(
   balanceDiffs: Capabilities.FillTransactionCapabilities['balanceDiffs'],
@@ -1110,6 +1122,7 @@ describe('behavior: path A — guaranteed sponsorship (no validate)', () => {
       relay({
         chains: [chain],
         features: 'all',
+        resolveTokens: () => localnetTokens,
         transports: { [chain.id]: http() },
         feePayer: {
           account: feePayerAccount,
@@ -1335,6 +1348,7 @@ describe('behavior: fee token resolution', () => {
       relay({
         chains: [chain],
         features: 'all',
+        resolveTokens: () => localnetTokens,
         transports: { [chain.id]: http() },
       }).listener,
     )
@@ -1366,30 +1380,62 @@ describe('behavior: fee token resolution', () => {
   })
 
   test('behavior: resolves to highest-balance token from token list', async () => {
-    // Mint different amounts of two tokens to a fresh account.
+    // Create a fresh TIP20 token "betaUsd" so we can test highest-balance
+    // selection without depending on a pre-deployed second token.
     const freshAccount = accounts[5]!
-    const betaUsd = '0x20c0000000000000000000000000000000000002'
-    const rpc = getClient()
-    await Actions.token.mintSync(rpc, {
-      account: accounts[0]!,
-      token: addresses.alphaUsd,
-      amount: 100n,
-      to: freshAccount.address,
+    const rpc = getClient({ account: accounts[0]! })
+    const { token: betaUsd } = await Actions.token.createSync(rpc, {
+      name: 'BetaUSD',
+      symbol: 'BetaUSD',
+      currency: 'USD',
+      quoteToken: addresses.alphaUsd,
     })
-    await Actions.token.mintSync(rpc, {
-      account: accounts[0]!,
-      token: betaUsd,
-      amount: 500n,
-      to: freshAccount.address,
+    await sendTransactionSync(rpc, {
+      calls: [
+        Actions.token.grantRoles.call({
+          token: betaUsd,
+          role: 'issuer',
+          to: rpc.account!.address,
+        }),
+        // Mint different amounts of two tokens to a fresh account. Amounts
+        // must be large enough to cover gas, otherwise autoSwap fires.
+        Actions.token.mint.call({
+          token: addresses.alphaUsd,
+          amount: parseUnits('100', 6),
+          to: freshAccount.address,
+        }),
+        Actions.token.mint.call({
+          token: betaUsd,
+          amount: parseUnits('500', 6),
+          to: freshAccount.address,
+        }),
+      ],
     })
 
-    const { transaction } = await fillTransaction(client, {
+    // Spin up a relay whose tokenlist includes the freshly created betaUsd
+    // alongside the localnet defaults so the highest-balance resolver can
+    // see both.
+    const customServer = await createServer(
+      relay({
+        chains: [chain],
+        features: 'all',
+        resolveTokens: () => [
+          ...localnetTokens,
+          { address: betaUsd, decimals: 6, name: 'BetaUSD', symbol: 'BetaUSD' },
+        ],
+        transports: { [chain.id]: http() },
+      }).listener,
+    )
+    const customClient = getClient({ transport: http(customServer.url) })
+
+    const { transaction } = await fillTransaction(customClient, {
       account: freshAccount.address,
       calls: [transferCall()],
     })
+    customServer.close()
 
     // betaUsd has higher balance (500 > 100).
-    expect(transaction.feeToken).toBe(betaUsd)
+    expect(transaction.feeToken?.toLowerCase()).toBe(betaUsd.toLowerCase())
   })
 
   test('behavior: falls back to pathUSD when no preference or balances', async () => {