@ape.swap/bonds-sdk 4.5.4-test.0 → 4.5.4-test.1

package/dist/ccip-DOs2Dd5_.js

@@ -0,0 +1,295 @@
+import { i as isAddress, I as InvalidAddressError, s as slice, t as toFunctionSelector, f as formatAbiItem, A as AbiFunctionSignatureNotFoundError, d as decodeAbiParameters, g as getAbiItem, a as AbiErrorNotFoundError, b as AbiErrorInputsNotFoundError, e as encodeAbiParameters, c as concatHex, h as AbiFunctionNotFoundError, j as AbiFunctionOutputsNotFoundError, k as InvalidArrayError, l as batchGatewayAbi, m as solidityError, B as BaseError, n as getUrl, o as stringify, p as decodeErrorResult, q as call, r as concat, H as HttpRequestError, u as isHex } from './main-B5Z7fuXw.js';
+import 'react';
+import '@tanstack/react-query';
+import 'wagmi';
+import 'axios';
+import '@solana/web3.js';
+import '@solana/rpc';
+import '@solana/kit';
+import '@solana/addresses';
+import '@solana/codecs';
+import '@solana/wallet-adapter-react';
+import '@solana/wallet-adapter-react-ui';
+import '@rainbow-me/rainbowkit';
+import '@solana/spl-token';
+
+function isAddressEqual(a, b) {
+    if (!isAddress(a, { strict: false }))
+        throw new InvalidAddressError({ address: a });
+    if (!isAddress(b, { strict: false }))
+        throw new InvalidAddressError({ address: b });
+    return a.toLowerCase() === b.toLowerCase();
+}
+
+function decodeFunctionData(parameters) {
+    const { abi, data } = parameters;
+    const signature = slice(data, 0, 4);
+    const description = abi.find((x) => x.type === 'function' &&
+        signature === toFunctionSelector(formatAbiItem(x)));
+    if (!description)
+        throw new AbiFunctionSignatureNotFoundError(signature, {
+            docsPath: '/docs/contract/decodeFunctionData',
+        });
+    return {
+        functionName: description.name,
+        args: ('inputs' in description &&
+            description.inputs &&
+            description.inputs.length > 0
+            ? decodeAbiParameters(description.inputs, slice(data, 4))
+            : undefined),
+    };
+}
+
+const docsPath$1 = '/docs/contract/encodeErrorResult';
+function encodeErrorResult(parameters) {
+    const { abi, errorName, args } = parameters;
+    let abiItem = abi[0];
+    if (errorName) {
+        const item = getAbiItem({ abi, args, name: errorName });
+        if (!item)
+            throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath$1 });
+        abiItem = item;
+    }
+    if (abiItem.type !== 'error')
+        throw new AbiErrorNotFoundError(undefined, { docsPath: docsPath$1 });
+    const definition = formatAbiItem(abiItem);
+    const signature = toFunctionSelector(definition);
+    let data = '0x';
+    if (args && args.length > 0) {
+        if (!abiItem.inputs)
+            throw new AbiErrorInputsNotFoundError(abiItem.name, { docsPath: docsPath$1 });
+        data = encodeAbiParameters(abiItem.inputs, args);
+    }
+    return concatHex([signature, data]);
+}
+
+const docsPath = '/docs/contract/encodeFunctionResult';
+function encodeFunctionResult(parameters) {
+    const { abi, functionName, result } = parameters;
+    let abiItem = abi[0];
+    if (functionName) {
+        const item = getAbiItem({ abi, name: functionName });
+        if (!item)
+            throw new AbiFunctionNotFoundError(functionName, { docsPath });
+        abiItem = item;
+    }
+    if (abiItem.type !== 'function')
+        throw new AbiFunctionNotFoundError(undefined, { docsPath });
+    if (!abiItem.outputs)
+        throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath });
+    const values = (() => {
+        if (abiItem.outputs.length === 0)
+            return [];
+        if (abiItem.outputs.length === 1)
+            return [result];
+        if (Array.isArray(result))
+            return result;
+        throw new InvalidArrayError(result);
+    })();
+    return encodeAbiParameters(abiItem.outputs, values);
+}
+
+const localBatchGatewayUrl = 'x-batch-gateway:true';
+async function localBatchGatewayRequest(parameters) {
+    const { data, ccipRequest } = parameters;
+    const { args: [queries], } = decodeFunctionData({ abi: batchGatewayAbi, data });
+    const failures = [];
+    const responses = [];
+    await Promise.all(queries.map(async (query, i) => {
+        try {
+            responses[i] = query.urls.includes(localBatchGatewayUrl)
+                ? await localBatchGatewayRequest({ data: query.data, ccipRequest })
+                : await ccipRequest(query);
+            failures[i] = false;
+        }
+        catch (err) {
+            failures[i] = true;
+            responses[i] = encodeError(err);
+        }
+    }));
+    return encodeFunctionResult({
+        abi: batchGatewayAbi,
+        functionName: 'query',
+        result: [failures, responses],
+    });
+}
+function encodeError(error) {
+    if (error.name === 'HttpRequestError' && error.status)
+        return encodeErrorResult({
+            abi: batchGatewayAbi,
+            errorName: 'HttpError',
+            args: [error.status, error.shortMessage],
+        });
+    return encodeErrorResult({
+        abi: [solidityError],
+        errorName: 'Error',
+        args: ['shortMessage' in error ? error.shortMessage : error.message],
+    });
+}
+
+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 };