@powerhousedao/connect 1.0.0 → 1.0.3-dev.0

package/dist/assets/ccip-Dn5Ob09y.js

@@ -0,0 +1,170 @@
+import { aD as BaseError, aE as getUrl, aF as stringify, aG as decodeErrorResult, aH as isAddressEqual, aI as call, aJ as concat, aK as encodeAbiParameters, aL as HttpRequestError, aM as isHex } from "./app-BYkaiTES.js";
+import "./main.CgKmK6gL.js";
+import "react/jsx-runtime";
+import "./app-loader-Bkg_WUos.js";
+import "react";
+import "@powerhousedao/reactor-browser";
+import "react-dom";
+import "@powerhousedao/reactor-browser/hooks/useUiNodesContext";
+import "@powerhousedao/reactor-browser/hooks/useDriveActionsWithUiNodes";
+import "@powerhousedao/reactor-browser/hooks/useDriveContext";
+import "@powerhousedao/reactor-browser/uiNodes/constants";
+import "@powerhousedao/reactor-browser/hooks/document-state";
+class OffchainLookupError extends BaseError {
+  constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
+    var _a;
+    super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
+      cause,
+      metaMessages: [
+        ...cause.metaMessages || [],
+        ((_a = cause.metaMessages) == null ? void 0 : _a.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 == null ? void 0 : ccipRead.request) === "function" ? ccipRead.request : ccipRequest;
+  try {
+    if (!isAddressEqual(to, sender))
+      throw new OffchainLookupSenderMismatchError({ sender, to });
+    const result = 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 }) {
+  var _a;
+  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 } : void 0;
+    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 ((_a = response.headers.get("Content-Type")) == null ? void 0 : _a.startsWith("application/json")) {
+        result = (await response.json()).data;
+      } else {
+        result = await response.text();
+      }
+      if (!response.ok) {
+        error = new HttpRequestError({
+          body,
+          details: (result == null ? void 0 : 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
+};