@yodlpay/tokenlists 1.0.1 → 1.1.0

package/README.md

@@ -71,6 +71,35 @@ const dai = getTokenBySymbol('DAI', 1);
 const weth = getNativeWrappedToken(1);
 ```
 
+### Stablecoins
+
+```typescript
+import {
+  isStablecoin,
+  getStablecoinCurrency,
+  getStablecoinInfo,
+  getStablecoinsByPeg,
+  type FiatCurrency,
+  type StablecoinCheckResult
+} from '@yodlpay/tokenlists';
+
+// Check if a token is a stablecoin (by coinGeckoId)
+isStablecoin('tether'); // true
+isStablecoin('ethereum'); // false
+
+// Get the currency a stablecoin is pegged to
+getStablecoinCurrency('usd-coin'); // 'USD'
+getStablecoinCurrency('euro-coin'); // 'EUR'
+
+// Get detailed stablecoin info for a token
+const token = getTokenBySymbol('USDC', 1);
+const info = getStablecoinInfo(token);
+// { isStablecoin: true, peggedTo: 'USD' }
+
+// Get all stablecoin coinGeckoIds for a currency
+getStablecoinsByPeg('EUR'); // ['euro-coin', 'monerium-eur-money', ...]
+```
+
 ### Router ABIs
 
 ```typescript
@@ -129,6 +158,23 @@ The package maintains two token lists:
 - **Featured** (`tokenlist-featured.json`) - Manually curated tokens with metadata updated from on-chain data
 - **Generated** (`tokenlist-generated.json`) - Auto-fetched tokens from external sources (cross-checked with other services as they are added)
 
+### Updating Stablecoin Registry
+
+```bash
+yarn update:stablecoins
+```
+
+Fetches stablecoin data from CoinGecko category APIs and updates `stablecoin-registry.json`. The script:
+
+1. Fetches tokens from CoinGecko stablecoin categories (USD, EUR, GBP, JPY, etc.)
+2. Filters to only include tokens present in the tokenlists (by coinGeckoId)
+3. Outputs a simple mapping of `coinGeckoId → peggedTo` currency
+
+To update everything at once:
+```bash
+yarn update:all  # Runs update:stablecoins then update
+```
+
 ### How `yarn update` Works
 
 1. **Fetch tokens from Relay Link API** - Discovers tokens across all supported chains

package/dist/ccip-Cm28A1_H.js

@@ -0,0 +1,181 @@
+import { B as BaseError, g as getUrl, s as stringify, d as decodeErrorResult, i as isAddressEqual, l as localBatchGatewayUrl, a as localBatchGatewayRequest, c as call, b as concat, e as encodeAbiParameters, H as HttpRequestError, f as isHex } from './index-C75unsqB.js';
+
+class OffchainLookupError extends BaseError {
+    constructor({ callbackSelector, cause, data, extraData, sender, urls }){
+        super(cause.shortMessage || 'An error occurred while fetching for an offchain result.', {
+            cause,
+            metaMessages: [
+                ...cause.metaMessages || [],
+                cause.metaMessages?.length ? '' : [],
+                'Offchain Gateway Call:',
+                urls && [
+                    '  Gateway URL(s):',
+                    ...urls.map((url)=>`    ${getUrl(url)}`)
+                ],
+                `  Sender: ${sender}`,
+                `  Data: ${data}`,
+                `  Callback selector: ${callbackSelector}`,
+                `  Extra data: ${extraData}`
+            ].flat(),
+            name: 'OffchainLookupError'
+        });
+    }
+}
+class OffchainLookupResponseMalformedError extends BaseError {
+    constructor({ result, url }){
+        super('Offchain gateway response is malformed. Response data must be a hex value.', {
+            metaMessages: [
+                `Gateway URL: ${getUrl(url)}`,
+                `Response: ${stringify(result)}`
+            ],
+            name: 'OffchainLookupResponseMalformedError'
+        });
+    }
+}
+class OffchainLookupSenderMismatchError extends BaseError {
+    constructor({ sender, to }){
+        super('Reverted sender address does not match target contract address (`to`).', {
+            metaMessages: [
+                `Contract address: ${to}`,
+                `OffchainLookup sender address: ${sender}`
+            ],
+            name: 'OffchainLookupSenderMismatchError'
+        });
+    }
+}
+
+const offchainLookupSignature = '0x556f1830';
+const offchainLookupAbiItem = {
+    name: 'OffchainLookup',
+    type: 'error',
+    inputs: [
+        {
+            name: 'sender',
+            type: 'address'
+        },
+        {
+            name: 'urls',
+            type: 'string[]'
+        },
+        {
+            name: 'callData',
+            type: 'bytes'
+        },
+        {
+            name: 'callbackFunction',
+            type: 'bytes4'
+        },
+        {
+            name: 'extraData',
+            type: 'bytes'
+        }
+    ]
+};
+async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
+    const { args } = decodeErrorResult({
+        data,
+        abi: [
+            offchainLookupAbiItem
+        ]
+    });
+    const [sender, urls, callData, callbackSelector, extraData] = args;
+    const { ccipRead } = client;
+    const ccipRequest_ = ccipRead && typeof ccipRead?.request === 'function' ? ccipRead.request : ccipRequest;
+    try {
+        if (!isAddressEqual(to, sender)) throw new OffchainLookupSenderMismatchError({
+            sender,
+            to
+        });
+        const result = urls.includes(localBatchGatewayUrl) ? await localBatchGatewayRequest({
+            data: callData,
+            ccipRequest: ccipRequest_
+        }) : await ccipRequest_({
+            data: callData,
+            sender,
+            urls
+        });
+        const { data: data_ } = await call(client, {
+            blockNumber,
+            blockTag,
+            data: concat([
+                callbackSelector,
+                encodeAbiParameters([
+                    {
+                        type: 'bytes'
+                    },
+                    {
+                        type: 'bytes'
+                    }
+                ], [
+                    result,
+                    extraData
+                ])
+            ]),
+            to
+        });
+        return data_;
+    } catch (err) {
+        throw new OffchainLookupError({
+            callbackSelector,
+            cause: err,
+            data,
+            extraData,
+            sender,
+            urls
+        });
+    }
+}
+async function ccipRequest({ data, sender, urls }) {
+    let error = new Error('An unknown error occurred.');
+    for(let i = 0; i < urls.length; i++){
+        const url = urls[i];
+        const method = url.includes('{data}') ? 'GET' : 'POST';
+        const body = method === 'POST' ? {
+            data,
+            sender
+        } : undefined;
+        const headers = method === 'POST' ? {
+            'Content-Type': 'application/json'
+        } : {};
+        try {
+            const response = await fetch(url.replace('{sender}', sender.toLowerCase()).replace('{data}', data), {
+                body: JSON.stringify(body),
+                headers,
+                method
+            });
+            let result;
+            if (response.headers.get('Content-Type')?.startsWith('application/json')) {
+                result = (await response.json()).data;
+            } else {
+                result = await response.text();
+            }
+            if (!response.ok) {
+                error = new HttpRequestError({
+                    body,
+                    details: result?.error ? stringify(result.error) : response.statusText,
+                    headers: response.headers,
+                    status: response.status,
+                    url
+                });
+                continue;
+            }
+            if (!isHex(result)) {
+                error = new OffchainLookupResponseMalformedError({
+                    result,
+                    url
+                });
+                continue;
+            }
+            return result;
+        } catch (err) {
+            error = new HttpRequestError({
+                body,
+                details: err.message,
+                url
+            });
+        }
+    }
+    throw error;
+}
+
+export { ccipRequest, offchainLookup, offchainLookupAbiItem, offchainLookupSignature };

package/dist/{ccip-CTW8a_vN.js → ccip-E6OCw-JN.cjs}

@@ -1,4 +1,4 @@
-var index = require('./index-Cso5F8p5.js');
+var index = require('./index-DPv0KZek.cjs');
 
 class OffchainLookupError extends index.BaseError {
     constructor({ callbackSelector, cause, data, extraData, sender, urls }){