@obscura-fhe/sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,670 @@
+'use strict';
+
+var viem = require('viem');
+var chains = require('viem/chains');
+var supabaseJs = require('@supabase/supabase-js');
+
+// src/config/defaults.ts
+var ARBITRUM_SEPOLIA_CHAIN_ID = 421614;
+var DEFAULT_RPC_URL = "https://sepolia-rollup.arbitrum.io/rpc";
+var DEFAULT_API_URL = "https://obscura-api-n62v.onrender.com";
+var DEFAULT_SUPABASE_URL = "https://quoovjkjwgtdqwdofubh.supabase.co";
+var DEFAULT_ADDRESSES = {
+  ocUSDC_Pay: "0xEd46020Df8abe7BB1E096f27d089F4326D223a53",
+  ObscuraPay: "0x91CdD9a481C732bEB09Ce039da23DC11e83547a4",
+  ObscuraPayStreamV3: "0xE4328F139F03138D63f7fdF90A8Ef240e04653fA",
+  ObscuraConfidentialEscrow: "0x293810A2081114CcE0c98A709a0c31aE07c01D75",
+  ObscuraInvoice: "0x62a86C8d68fF32ea41Faf349db6EF7EF496620b7",
+  ObscuraStealthRegistry: "0xa36e791a611D36e2C817a7DA0f41547D30D4917d",
+  ObscuraVote: "0xe358776AfdbA95d7c9F040e6ef1f5A021aF91730",
+  ObscuraTreasury: "0x89252ee3f920978EEfDB650760fe56BA1Ede8c08",
+  ObscuraRewards: "0x435ea117404553A6868fbe728A7A284FCEd15BC2",
+  ObscuraCreditFactory: "0x5aDC1965D155f4b18119222CBA7a7A4be4F45680",
+  ObscuraCreditOracle: "0x5F00910533AB6fc12a35a87BaFe856EF2cb323c3",
+  ObscuraCreditIRM: "0xA072c038cE98dEC8F5350D451145fB98F5EA57Bc",
+  ObscuraCreditAuction: "0x205FfC0A3b8207B645c1a6B1b4805eb3FfC828F0",
+  ObscuraCreditScoreV2: "0xe5B0c6c06C0B1fd7d7CD5D2e93997693863d3D4D",
+  CreditCanonicalPayOcUSDCMarket: "0x1Ec113297c7F9516A6604aa3b18C180559a6f551",
+  v2_ConservativeVault: "0xCEBb042ae8FDE217a9FdE5b8a82E23827FdBB898",
+  v2_BalancedVault: "0xF508315bD4C5EC4c71C5E431AE972C0dC6B78Bbc",
+  ObscuraGovernor: "0xE4807C9F90a0da8F5B5bafa4361B15ff855b7186",
+  ObscuraTimelock: "0x07b7961627f433a1d9001F82Ac4af9F19b9a9E05"
+};
+function mergeAddresses(partial) {
+  return { ...DEFAULT_ADDRESSES, ...partial };
+}
+
+// src/fhe/types.ts
+var FheRequiredError = class extends Error {
+  constructor(operation) {
+    super(
+      `FHE provider required for ${operation}. Pass fhe in ObscuraSDK.create() or supply a pre-encrypted InEuint64.`
+    );
+    this.name = "FheRequiredError";
+  }
+};
+
+// src/core/utils.ts
+async function resolveInEuint64(value, contractAddress, fhe, preEncrypted) {
+  if (preEncrypted) return preEncrypted;
+  if (!fhe) throw new FheRequiredError("encrypted amount");
+  return fhe.encryptUint64(value, { contractAddress });
+}
+function toContractInEuint64(input) {
+  return {
+    ctHash: input.ctHash,
+    securityZone: input.securityZone,
+    utype: input.utype,
+    signature: input.signature
+  };
+}
+function normalizeWallet(wallet) {
+  if (!/^0x[0-9a-fA-F]{40}$/.test(wallet)) return null;
+  return wallet.toLowerCase();
+}
+function stripTrailingSlash(url) {
+  return url.replace(/\/$/, "");
+}
+
+// src/core/http.ts
+var HttpClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  baseUrl;
+  get url() {
+    return stripTrailingSlash(this.baseUrl);
+  }
+  async get(path, init) {
+    const response = await fetch(`${this.url}${path}`, {
+      ...init,
+      method: "GET",
+      headers: { Accept: "application/json", ...init?.headers }
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new HttpError(response.status, `GET ${path} failed (${response.status})${body ? `: ${body}` : ""}`);
+    }
+    return response.json();
+  }
+  async post(path, body, init) {
+    const response = await fetch(`${this.url}${path}`, {
+      ...init,
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...init?.headers
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new HttpError(response.status, `POST ${path} failed (${response.status})${text ? `: ${text}` : ""}`);
+    }
+    return response.json();
+  }
+  async delete(path, body, init) {
+    const response = await fetch(`${this.url}${path}`, {
+      ...init,
+      method: "DELETE",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...init?.headers
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new HttpError(response.status, `DELETE ${path} failed (${response.status})${text ? `: ${text}` : ""}`);
+    }
+    return response.json();
+  }
+};
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+  status;
+};
+function resolveChain(chainId) {
+  if (chainId === ARBITRUM_SEPOLIA_CHAIN_ID) return chains.arbitrumSepolia;
+  return {
+    ...chains.arbitrumSepolia,
+    id: chainId
+  };
+}
+function createDefaultPublicClient(rpcUrl, chainId) {
+  return viem.createPublicClient({
+    chain: resolveChain(chainId),
+    transport: viem.http(rpcUrl || DEFAULT_RPC_URL)
+  });
+}
+function encodeCall(call) {
+  return viem.encodeFunctionData({
+    abi: call.abi,
+    functionName: call.functionName,
+    args: [...call.args]
+  });
+}
+async function sendContractCall(call, walletClient, account) {
+  const hash = await walletClient.writeContract({
+    address: call.address,
+    abi: call.abi,
+    functionName: call.functionName,
+    args: [...call.args],
+    chain: resolveChain(call.chainId),
+    account
+  });
+  return hash;
+}
+function makeCall(chainId, address, abi, functionName, args) {
+  return { address, abi, functionName, args, chainId };
+}
+
+// src/config/activity-filters.ts
+var CREDIT_ACTIVITY_EVENT_NAMES = [
+  "ObscuraCreditMarket.Supplied",
+  "ObscuraCreditMarket.Withdrawn",
+  "ObscuraCreditMarket.Borrowed",
+  "ObscuraCreditMarket.Repaid",
+  "ObscuraCreditMarket.Liquidated",
+  "ObscuraCreditMarket.CollateralSupplied",
+  "ObscuraCreditMarket.CollateralWithdrawn",
+  "ObscuraCreditVault.Deposited",
+  "ObscuraCreditVault.Withdrew",
+  "ObscuraCreditAuction.AuctionCreated",
+  "ObscuraCreditAuction.BidPlaced",
+  "ObscuraCreditAuction.AuctionSettled",
+  "ObscuraCreditScoreV2.ScoreUpdated"
+];
+var VOTE_ACTIVITY_EVENT_NAMES = [
+  "ObscuraVote.ProposalCreated",
+  "ObscuraVote.VoteCast",
+  "ObscuraVote.VoteChanged",
+  "ObscuraVote.Delegated",
+  "ObscuraVote.DelegationRemoved",
+  "ObscuraVote.ProposalFinalized",
+  "ObscuraTreasury.SpendAttached",
+  "ObscuraTreasury.SpendExecuted",
+  "ObscuraRewards.RewardAccrued",
+  "ObscuraRewards.RewardWithdrawn"
+];
+var ACTIVITY_EVENT_FILTERS = {
+  all: [],
+  sent: ["ObscuraPay.PaymentSent"],
+  received: ["ObscuraPay.PaymentReceived"],
+  stream: [
+    "ObscuraPayStreamV2.StreamCreated",
+    "ObscuraPayStreamV2.StreamCancelled",
+    "ObscuraPayStreamV2.StreamWithdrawn",
+    "ObscuraPayStreamV3.StreamCreated",
+    "ObscuraPayStreamV3.StreamCancelled",
+    "ObscuraPayStreamV3.CycleSettled"
+  ],
+  invoice: ["ObscuraInvoice.InvoiceCreated", "ObscuraInvoice.InvoicePaid"],
+  escrow: [
+    "ObscuraConfidentialEscrow.EscrowCreated",
+    "ObscuraConfidentialEscrow.EscrowFunded",
+    "ObscuraConfidentialEscrow.EscrowRedeemed",
+    "ObscuraConfidentialEscrow.EscrowCancelled",
+    "ObscuraConfidentialEscrow.EscrowRefunded"
+  ],
+  stealth: ["ObscuraStealthRegistry.Announcement", "ObscuraStealthRegistry.MetaAddressSet"],
+  credit: CREDIT_ACTIVITY_EVENT_NAMES,
+  vote: VOTE_ACTIVITY_EVENT_NAMES
+};
+
+// src/modules/activity.ts
+var DEFAULT_PAGE_SIZE = 20;
+var ActivityModule = class {
+  client;
+  constructor(supabaseUrl, supabaseAnonKey) {
+    this.client = supabaseUrl && supabaseAnonKey ? supabaseJs.createClient(supabaseUrl, supabaseAnonKey) : null;
+  }
+  getEventFilters() {
+    return ACTIVITY_EVENT_FILTERS;
+  }
+  async listForWallet(wallet, options = {}) {
+    if (!this.client) {
+      throw new Error(
+        "Supabase not configured. Pass supabaseUrl and supabaseAnonKey to ObscuraSDK.create()."
+      );
+    }
+    const normalized = normalizeWallet(wallet);
+    if (!normalized) throw new Error("Invalid wallet address");
+    const filter = options.filter ?? "all";
+    const page = options.page ?? 0;
+    const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+    let query = this.client.from("obscura_activity").select("*").contains("participants", [normalized]).order("block_number", { ascending: false }).range(page * pageSize, page * pageSize + pageSize - 1);
+    const allowed = ACTIVITY_EVENT_FILTERS[filter];
+    if (allowed.length > 0) {
+      query = query.in("event_name", [...allowed]);
+    }
+    const { data, error } = await query;
+    if (error) throw new Error(error.message);
+    const items = data ?? [];
+    return {
+      items,
+      page,
+      pageSize,
+      hasMore: items.length === pageSize
+    };
+  }
+};
+
+// src/abis/index.ts
+var IN_EUINT64_COMPONENTS = [
+  { name: "ctHash", type: "uint256" },
+  { name: "securityZone", type: "uint8" },
+  { name: "utype", type: "uint8" },
+  { name: "signature", type: "bytes" }
+];
+var OC_USDC_PAY_ABI = [
+  {
+    name: "confidentialBalanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "shield",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "encryptedAmount", type: "tuple", components: [...IN_EUINT64_COMPONENTS] }
+    ],
+    outputs: []
+  },
+  {
+    name: "unshield",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "encryptedAmount", type: "tuple", components: [...IN_EUINT64_COMPONENTS] }
+    ],
+    outputs: []
+  },
+  {
+    name: "confidentialTransfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "encryptedAmount", type: "tuple", components: [...IN_EUINT64_COMPONENTS] }
+    ],
+    outputs: []
+  }
+];
+var CREDIT_MARKET_ABI = [
+  {
+    name: "supplyCollateral",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "encryptedAmount", type: "tuple", components: [...IN_EUINT64_COMPONENTS] }
+    ],
+    outputs: []
+  },
+  {
+    name: "borrow",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "encryptedAmount", type: "tuple", components: [...IN_EUINT64_COMPONENTS] }
+    ],
+    outputs: []
+  },
+  {
+    name: "repay",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "encryptedAmount", type: "tuple", components: [...IN_EUINT64_COMPONENTS] }
+    ],
+    outputs: []
+  }
+];
+var OBSCURA_VOTE_ABI = [
+  {
+    name: "proposalCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getProposal",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: [
+      { name: "creator", type: "address" },
+      { name: "title", type: "string" },
+      { name: "description", type: "string" },
+      { name: "options", type: "string[]" },
+      { name: "startTime", type: "uint256" },
+      { name: "endTime", type: "uint256" },
+      { name: "finalized", type: "bool" },
+      { name: "winningOption", type: "uint256" }
+    ]
+  },
+  {
+    name: "castVote",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "proposalId", type: "uint256" },
+      { name: "encryptedOption", type: "tuple", components: [...IN_EUINT64_COMPONENTS] }
+    ],
+    outputs: []
+  },
+  {
+    name: "delegate",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "delegatee", type: "address" }],
+    outputs: []
+  }
+];
+
+// src/modules/credit.ts
+var CreditModule = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  getMarketAddress(override) {
+    return override ?? this.deps.addresses.CreditCanonicalPayOcUSDCMarket;
+  }
+  async buildSupplyCollateral(amount, encryptedAmount, marketAddress) {
+    const market = this.getMarketAddress(marketAddress);
+    const enc = await resolveInEuint64(amount, market, this.deps.fhe, encryptedAmount);
+    return makeCall(this.deps.chainId, market, CREDIT_MARKET_ABI, "supplyCollateral", [
+      toContractInEuint64(enc)
+    ]);
+  }
+  async buildBorrow(amount, encryptedAmount, marketAddress) {
+    const market = this.getMarketAddress(marketAddress);
+    const enc = await resolveInEuint64(amount, market, this.deps.fhe, encryptedAmount);
+    return makeCall(this.deps.chainId, market, CREDIT_MARKET_ABI, "borrow", [
+      toContractInEuint64(enc)
+    ]);
+  }
+  async buildRepay(amount, encryptedAmount, marketAddress) {
+    const market = this.getMarketAddress(marketAddress);
+    const enc = await resolveInEuint64(amount, market, this.deps.fhe, encryptedAmount);
+    return makeCall(this.deps.chainId, market, CREDIT_MARKET_ABI, "repay", [
+      toContractInEuint64(enc)
+    ]);
+  }
+};
+
+// src/modules/notifications.ts
+var NotificationsModule = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  http;
+  async getVapidPublicKey() {
+    const { publicKey } = await this.http.get("/vapid-public-key");
+    return publicKey;
+  }
+  async getPrefs(wallet) {
+    const normalized = normalizeWallet(wallet);
+    if (!normalized) throw new Error("Invalid wallet address");
+    try {
+      return await this.http.get(`/prefs/${normalized}`);
+    } catch (err) {
+      if (err instanceof HttpError && err.status === 404) return null;
+      throw err;
+    }
+  }
+  async savePrefs(prefs) {
+    const normalized = normalizeWallet(prefs.wallet);
+    if (!normalized) throw new Error("Invalid wallet address");
+    await this.http.post("/prefs", {
+      ...prefs,
+      wallet: normalized
+    });
+  }
+  async subscribe(wallet, subscription) {
+    const normalized = normalizeWallet(wallet);
+    if (!normalized) throw new Error("Invalid wallet address");
+    if (!subscription?.endpoint) throw new Error("subscription.endpoint is required");
+    await this.http.post("/subscribe", { wallet: normalized, subscription });
+  }
+  async unsubscribe(wallet) {
+    const normalized = normalizeWallet(wallet);
+    if (!normalized) throw new Error("Invalid wallet address");
+    await this.http.delete("/subscribe", { wallet: normalized });
+  }
+};
+
+// src/modules/pay.ts
+var PayModule = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  get ocUsdcAddress() {
+    return this.deps.addresses.ocUSDC_Pay;
+  }
+  /** Returns encrypted balance ctHash (uint256) for account */
+  async getShieldedBalance(account) {
+    return this.deps.publicClient.readContract({
+      address: this.deps.addresses.ocUSDC_Pay,
+      abi: OC_USDC_PAY_ABI,
+      functionName: "confidentialBalanceOf",
+      args: [account]
+    });
+  }
+  async buildShield(amount, encryptedAmount) {
+    const enc = await resolveInEuint64(
+      amount,
+      this.deps.addresses.ocUSDC_Pay,
+      this.deps.fhe,
+      encryptedAmount
+    );
+    return makeCall(
+      this.deps.chainId,
+      this.deps.addresses.ocUSDC_Pay,
+      OC_USDC_PAY_ABI,
+      "shield",
+      [amount, toContractInEuint64(enc)]
+    );
+  }
+  async buildUnshield(to, amount, encryptedAmount) {
+    const enc = await resolveInEuint64(
+      amount,
+      this.deps.addresses.ocUSDC_Pay,
+      this.deps.fhe,
+      encryptedAmount
+    );
+    return makeCall(
+      this.deps.chainId,
+      this.deps.addresses.ocUSDC_Pay,
+      OC_USDC_PAY_ABI,
+      "unshield",
+      [to, toContractInEuint64(enc)]
+    );
+  }
+  async buildTransfer(to, amount, encryptedAmount) {
+    const enc = await resolveInEuint64(
+      amount,
+      this.deps.addresses.ocUSDC_Pay,
+      this.deps.fhe,
+      encryptedAmount
+    );
+    return makeCall(
+      this.deps.chainId,
+      this.deps.addresses.ocUSDC_Pay,
+      OC_USDC_PAY_ABI,
+      "confidentialTransfer",
+      [to, toContractInEuint64(enc)]
+    );
+  }
+};
+
+// src/modules/reputation.ts
+var ReputationModule = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  http;
+  async getSummary(wallet) {
+    const normalized = normalizeWallet(wallet);
+    if (!normalized) {
+      throw new Error("Invalid wallet address");
+    }
+    return this.http.get(`/reputation/${normalized}`);
+  }
+};
+
+// src/modules/vote.ts
+var VoteModule = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  get voteAddress() {
+    return this.deps.addresses.ObscuraVote;
+  }
+  async getProposalCount() {
+    return this.deps.publicClient.readContract({
+      address: this.deps.addresses.ObscuraVote,
+      abi: OBSCURA_VOTE_ABI,
+      functionName: "proposalCount"
+    });
+  }
+  async getProposal(id) {
+    const result = await this.deps.publicClient.readContract({
+      address: this.deps.addresses.ObscuraVote,
+      abi: OBSCURA_VOTE_ABI,
+      functionName: "getProposal",
+      args: [id]
+    });
+    return {
+      id,
+      creator: result[0],
+      title: result[1],
+      description: result[2],
+      options: [...result[3]],
+      startTime: result[4],
+      endTime: result[5],
+      finalized: result[6],
+      winningOption: result[7]
+    };
+  }
+  async buildCastVote(proposalId, optionIndex, encryptedOption) {
+    const enc = await resolveInEuint64(
+      BigInt(optionIndex),
+      this.deps.addresses.ObscuraVote,
+      this.deps.fhe,
+      encryptedOption
+    );
+    return makeCall(
+      this.deps.chainId,
+      this.deps.addresses.ObscuraVote,
+      OBSCURA_VOTE_ABI,
+      "castVote",
+      [proposalId, toContractInEuint64(enc)]
+    );
+  }
+  buildDelegate(delegatee) {
+    return makeCall(
+      this.deps.chainId,
+      this.deps.addresses.ObscuraVote,
+      OBSCURA_VOTE_ABI,
+      "delegate",
+      [delegatee]
+    );
+  }
+};
+
+// src/client.ts
+var ObscuraSDK = class _ObscuraSDK {
+  chainId;
+  addresses;
+  publicClient;
+  fhe;
+  pay;
+  credit;
+  vote;
+  reputation;
+  activity;
+  notifications;
+  walletClient;
+  constructor(config) {
+    this.chainId = config.chainId ?? ARBITRUM_SEPOLIA_CHAIN_ID;
+    this.addresses = mergeAddresses(config.addresses);
+    this.fhe = config.fhe;
+    this.walletClient = config.walletClient;
+    const rpcUrl = config.rpcUrl ?? DEFAULT_RPC_URL;
+    this.publicClient = config.publicClient ?? createDefaultPublicClient(rpcUrl, this.chainId);
+    const apiUrl = config.apiUrl ?? DEFAULT_API_URL;
+    const http2 = new HttpClient(apiUrl);
+    const moduleDeps = {
+      chainId: this.chainId,
+      addresses: this.addresses,
+      publicClient: this.publicClient,
+      fhe: this.fhe
+    };
+    this.pay = new PayModule(moduleDeps);
+    this.credit = new CreditModule({
+      chainId: this.chainId,
+      addresses: this.addresses,
+      fhe: this.fhe
+    });
+    this.vote = new VoteModule(moduleDeps);
+    this.reputation = new ReputationModule(http2);
+    this.notifications = new NotificationsModule(http2);
+    this.activity = new ActivityModule(
+      config.supabaseUrl ?? DEFAULT_SUPABASE_URL,
+      config.supabaseAnonKey
+    );
+  }
+  static create(config = {}) {
+    return new _ObscuraSDK(config);
+  }
+  encodeCall(call) {
+    return encodeCall(call);
+  }
+  async sendCall(call, account) {
+    if (!this.walletClient) {
+      throw new Error("walletClient required for sendCall. Pass walletClient in ObscuraSDK.create().");
+    }
+    return sendContractCall(call, this.walletClient, account);
+  }
+};
+
+exports.ACTIVITY_EVENT_FILTERS = ACTIVITY_EVENT_FILTERS;
+exports.ARBITRUM_SEPOLIA_CHAIN_ID = ARBITRUM_SEPOLIA_CHAIN_ID;
+exports.ActivityModule = ActivityModule;
+exports.CREDIT_MARKET_ABI = CREDIT_MARKET_ABI;
+exports.CreditModule = CreditModule;
+exports.DEFAULT_ADDRESSES = DEFAULT_ADDRESSES;
+exports.DEFAULT_API_URL = DEFAULT_API_URL;
+exports.DEFAULT_RPC_URL = DEFAULT_RPC_URL;
+exports.DEFAULT_SUPABASE_URL = DEFAULT_SUPABASE_URL;
+exports.FheRequiredError = FheRequiredError;
+exports.HttpError = HttpError;
+exports.NotificationsModule = NotificationsModule;
+exports.OBSCURA_VOTE_ABI = OBSCURA_VOTE_ABI;
+exports.OC_USDC_PAY_ABI = OC_USDC_PAY_ABI;
+exports.ObscuraSDK = ObscuraSDK;
+exports.PayModule = PayModule;
+exports.ReputationModule = ReputationModule;
+exports.VoteModule = VoteModule;
+exports.createDefaultPublicClient = createDefaultPublicClient;
+exports.encodeCall = encodeCall;
+exports.normalizeWallet = normalizeWallet;
+exports.toContractInEuint64 = toContractInEuint64;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map