import { l as p, m, n as w, o as k, q as b, r as L, t as O, u as R, v as x, x as E, H as y, y as M } from "./en_US-IFPOGBSL-Dqe3iO9V.js";
class q extends p {
  constructor({ callbackSelector: s, cause: e, data: o, extraData: n, sender: c, urls: t }) {
    super(e.shortMessage || "An error occurred while fetching for an offchain result.", {
      cause: e,
      metaMessages: [
        ...e.metaMessages || [],
        e.metaMessages?.length ? "" : [],
        "Offchain Gateway Call:",
        t && [
          "  Gateway URL(s):",
          ...t.map((i) => `    ${m(i)}`)
        ],
        `  Sender: ${c}`,
        `  Data: ${o}`,
        `  Callback selector: ${s}`,
        `  Extra data: ${n}`
      ].flat(),
      name: "OffchainLookupError"
    });
  }
}
class S extends p {
  constructor({ result: s, url: e }) {
    super("Offchain gateway response is malformed. Response data must be a hex value.", {
      metaMessages: [
        `Gateway URL: ${m(e)}`,
        `Response: ${w(s)}`
      ],
      name: "OffchainLookupResponseMalformedError"
    });
  }
}
class $ extends p {
  constructor({ sender: s, to: e }) {
    super("Reverted sender address does not match target contract address (`to`).", {
      metaMessages: [
        `Contract address: ${e}`,
        `OffchainLookup sender address: ${s}`
      ],
      name: "OffchainLookupSenderMismatchError"
    });
  }
}
const A = "0x556f1830", T = {
  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 D(d, { blockNumber: s, blockTag: e, data: o, to: n }) {
  const { args: c } = k({
    data: o,
    abi: [T]
  }), [t, i, l, a, r] = c, { ccipRead: u } = d, h = u && typeof u?.request == "function" ? u.request : C;
  try {
    if (!b(n, t))
      throw new $({ sender: t, to: n });
    const f = i.includes(L) ? await O({
      data: l,
      ccipRequest: h
    }) : await h({ data: l, sender: t, urls: i }), { data: g } = await R(d, {
      blockNumber: s,
      blockTag: e,
      data: x([
        a,
        E([{ type: "bytes" }, { type: "bytes" }], [f, r])
      ]),
      to: n
    });
    return g;
  } catch (f) {
    throw new q({
      callbackSelector: a,
      cause: f,
      data: o,
      extraData: r,
      sender: t,
      urls: i
    });
  }
}
async function C({ data: d, sender: s, urls: e }) {
  let o = new Error("An unknown error occurred.");
  for (let n = 0; n < e.length; n++) {
    const c = e[n], t = c.includes("{data}") ? "GET" : "POST", i = t === "POST" ? { data: d, sender: s } : void 0, l = t === "POST" ? { "Content-Type": "application/json" } : {};
    try {
      const a = await fetch(c.replace("{sender}", s.toLowerCase()).replace("{data}", d), {
        body: JSON.stringify(i),
        headers: l,
        method: t
      });
      let r;
      if (a.headers.get("Content-Type")?.startsWith("application/json") ? r = (await a.json()).data : r = await a.text(), !a.ok) {
        o = new y({
          body: i,
          details: r?.error ? w(r.error) : a.statusText,
          headers: a.headers,
          status: a.status,
          url: c
        });
        continue;
      }
      if (!M(r)) {
        o = new S({
          result: r,
          url: c
        });
        continue;
      }
      return r;
    } catch (a) {
      o = new y({
        body: i,
        details: a.message,
        url: c
      });
    }
  }
  throw o;
}
export {
  C as ccipRequest,
  D as offchainLookup,
  T as offchainLookupAbiItem,
  A as offchainLookupSignature
};
