@yodlpay/tokenlists 1.0.1 → 1.0.2

package/dist/ccip-BXviIVTm.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-QILtCArq.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-BgzcZHmu.cjs}

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

package/dist/{index-Cso5F8p5.js → index-BxN39P-j.cjs}

@@ -16696,7 +16696,7 @@ const schedulerCache = /*#__PURE__*/ new Map();
     } catch (err) {
         const data = getRevertErrorData(err);
         // Check for CCIP-Read offchain lookup signature.
-        const { offchainLookup, offchainLookupSignature } = await Promise.resolve().then(function () { return require('./ccip-CTW8a_vN.js'); });
+        const { offchainLookup, offchainLookupSignature } = await Promise.resolve().then(function () { return require('./ccip-BgzcZHmu.cjs'); });
         if (client.ccipRead !== false && data?.slice(0, 10) === offchainLookupSignature && to) return {
             data: await offchainLookup(client, {
                 data,