@qorechain/evm 0.3.0

package/dist/index.cjs

@@ -0,0 +1,1010 @@
+'use strict';
+
+var viem = require('viem');
+var accounts = require('viem/accounts');
+
+// src/client.ts
+function resolveRpcUrl(opts) {
+  const url = opts.rpcUrl ?? opts.endpoints?.evmRpc;
+  if (!url) {
+    throw new Error("createEvmClient: provide `rpcUrl` or `endpoints.evmRpc`");
+  }
+  return url;
+}
+function resolveWsUrl(opts) {
+  return opts.wsUrl ?? opts.endpoints?.evmWs;
+}
+async function createEvmClient(opts) {
+  const rpcUrl = resolveRpcUrl(opts);
+  const wsUrl = resolveWsUrl(opts);
+  const transport = opts.transport ?? viem.http(rpcUrl);
+  const decimals = opts.decimals ?? 18;
+  let chainId = opts.chainId;
+  if (chainId === void 0) {
+    const probe = viem.createPublicClient({ transport });
+    chainId = await probe.getChainId();
+  }
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "QoreChain EVM",
+    nativeCurrency: { name: "QOR", symbol: "QOR", decimals },
+    rpcUrls: {
+      default: {
+        http: [rpcUrl],
+        ...wsUrl ? { webSocket: [wsUrl] } : {}
+      }
+    }
+  });
+  const publicClient = viem.createPublicClient({ chain, transport });
+  const getWalletClient = (account) => viem.createWalletClient({ account, chain, transport });
+  return {
+    publicClient,
+    getWalletClient,
+    chain,
+    getChainId: async () => chainId
+  };
+}
+function evmAccountFromPrivateKey(privateKey) {
+  return accounts.privateKeyToAccount(privateKey);
+}
+
+// src/abi.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "transfer",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "value", type: "uint256" }
+    ]
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "spender", type: "address" },
+      { indexed: false, name: "value", type: "uint256" }
+    ]
+  }
+];
+var ERC721_ABI = [
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "tokenURI",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "getApproved",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "isApprovedForAll",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "setApprovalForAll",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: true, name: "tokenId", type: "uint256" }
+    ]
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "approved", type: "address" },
+      { indexed: true, name: "tokenId", type: "uint256" }
+    ]
+  },
+  {
+    type: "event",
+    name: "ApprovalForAll",
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: false, name: "approved", type: "bool" }
+    ]
+  }
+];
+var ERC1155_ABI = [
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "id", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "balanceOfBatch",
+    stateMutability: "view",
+    inputs: [
+      { name: "accounts", type: "address[]" },
+      { name: "ids", type: "uint256[]" }
+    ],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    type: "function",
+    name: "uri",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "isApprovedForAll",
+    stateMutability: "view",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "setApprovalForAll",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "id", type: "uint256" },
+      { name: "amount", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "safeBatchTransferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "ids", type: "uint256[]" },
+      { name: "amounts", type: "uint256[]" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  },
+  {
+    type: "event",
+    name: "TransferSingle",
+    inputs: [
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "id", type: "uint256" },
+      { indexed: false, name: "value", type: "uint256" }
+    ]
+  },
+  {
+    type: "event",
+    name: "ApprovalForAll",
+    inputs: [
+      { indexed: true, name: "account", type: "address" },
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: false, name: "approved", type: "bool" }
+    ]
+  }
+];
+var IQORE_PQC_ABI = [
+  {
+    type: "function",
+    name: "pqcVerify",
+    stateMutability: "view",
+    inputs: [
+      { name: "pubkey", type: "bytes" },
+      { name: "signature", type: "bytes" },
+      { name: "message", type: "bytes" }
+    ],
+    outputs: [{ name: "valid", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "pqcKeyStatus",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [
+      { name: "registered", type: "bool" },
+      { name: "algorithmId", type: "uint8" },
+      { name: "pubkey", type: "bytes" }
+    ]
+  }
+];
+var IQORE_AI_ABI = [
+  {
+    type: "function",
+    name: "aiRiskScore",
+    stateMutability: "view",
+    inputs: [{ name: "txData", type: "bytes" }],
+    outputs: [
+      { name: "score", type: "uint256" },
+      { name: "level", type: "uint8" }
+    ]
+  },
+  {
+    type: "function",
+    name: "aiAnomalyCheck",
+    stateMutability: "view",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [
+      { name: "anomalyScore", type: "uint256" },
+      { name: "flagged", type: "bool" }
+    ]
+  }
+];
+var IQORE_CONSENSUS_ABI = [
+  {
+    type: "function",
+    name: "rlConsensusParams",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "blockTime", type: "uint256" },
+      { name: "baseGasPrice", type: "uint256" },
+      { name: "validatorSetSize", type: "uint256" },
+      { name: "epoch", type: "uint256" }
+    ]
+  }
+];
+
+// src/erc20.ts
+function balanceOf(client, token, account) {
+  return client.readContract({
+    address: token,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [account]
+  });
+}
+function allowance(client, token, owner, spender) {
+  return client.readContract({
+    address: token,
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+}
+async function metadata(client, token) {
+  const [name2, symbol2, decimals] = await Promise.all([
+    client.readContract({ address: token, abi: ERC20_ABI, functionName: "name" }),
+    client.readContract({ address: token, abi: ERC20_ABI, functionName: "symbol" }),
+    client.readContract({ address: token, abi: ERC20_ABI, functionName: "decimals" })
+  ]);
+  return { name: name2, symbol: symbol2, decimals };
+}
+function transfer(client, token, to, amount) {
+  return client.writeContract({
+    address: token,
+    abi: ERC20_ABI,
+    functionName: "transfer",
+    args: [to, amount],
+    account: client.account,
+    chain: client.chain
+  });
+}
+function approve(client, token, spender, amount) {
+  return client.writeContract({
+    address: token,
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [spender, amount],
+    account: client.account,
+    chain: client.chain
+  });
+}
+var erc20 = {
+  balanceOf,
+  allowance,
+  metadata,
+  transfer,
+  approve
+};
+
+// src/erc721.ts
+function balanceOf2(client, token, owner) {
+  return client.readContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "balanceOf",
+    args: [owner]
+  });
+}
+function ownerOf(client, token, tokenId) {
+  return client.readContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "ownerOf",
+    args: [tokenId]
+  });
+}
+function tokenURI(client, token, tokenId) {
+  return client.readContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "tokenURI",
+    args: [tokenId]
+  });
+}
+function getApproved(client, token, tokenId) {
+  return client.readContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "getApproved",
+    args: [tokenId]
+  });
+}
+function isApprovedForAll(client, token, owner, operator) {
+  return client.readContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "isApprovedForAll",
+    args: [owner, operator]
+  });
+}
+function name(client, token) {
+  return client.readContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "name"
+  });
+}
+function symbol(client, token) {
+  return client.readContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "symbol"
+  });
+}
+async function metadata2(client, token) {
+  const [n, s] = await Promise.all([name(client, token), symbol(client, token)]);
+  return { name: n, symbol: s };
+}
+function approve2(client, token, to, tokenId) {
+  return client.writeContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "approve",
+    args: [to, tokenId],
+    account: client.account,
+    chain: client.chain
+  });
+}
+function setApprovalForAll(client, token, operator, approved) {
+  return client.writeContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "setApprovalForAll",
+    args: [operator, approved],
+    account: client.account,
+    chain: client.chain
+  });
+}
+function transferFrom(client, token, from, to, tokenId) {
+  return client.writeContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "transferFrom",
+    args: [from, to, tokenId],
+    account: client.account,
+    chain: client.chain
+  });
+}
+function safeTransferFrom(client, token, from, to, tokenId, data) {
+  if (data !== void 0) {
+    return client.writeContract({
+      address: token,
+      abi: ERC721_ABI,
+      functionName: "safeTransferFrom",
+      args: [from, to, tokenId, data],
+      account: client.account,
+      chain: client.chain
+    });
+  }
+  return client.writeContract({
+    address: token,
+    abi: ERC721_ABI,
+    functionName: "safeTransferFrom",
+    args: [from, to, tokenId],
+    account: client.account,
+    chain: client.chain
+  });
+}
+var erc721 = {
+  balanceOf: balanceOf2,
+  ownerOf,
+  tokenURI,
+  getApproved,
+  isApprovedForAll,
+  name,
+  symbol,
+  metadata: metadata2,
+  approve: approve2,
+  setApprovalForAll,
+  transferFrom,
+  safeTransferFrom
+};
+
+// src/erc1155.ts
+function balanceOf3(client, token, account, id) {
+  return client.readContract({
+    address: token,
+    abi: ERC1155_ABI,
+    functionName: "balanceOf",
+    args: [account, id]
+  });
+}
+function balanceOfBatch(client, token, accounts, ids) {
+  return client.readContract({
+    address: token,
+    abi: ERC1155_ABI,
+    functionName: "balanceOfBatch",
+    args: [accounts, ids]
+  });
+}
+function uri(client, token, id) {
+  return client.readContract({
+    address: token,
+    abi: ERC1155_ABI,
+    functionName: "uri",
+    args: [id]
+  });
+}
+function isApprovedForAll2(client, token, account, operator) {
+  return client.readContract({
+    address: token,
+    abi: ERC1155_ABI,
+    functionName: "isApprovedForAll",
+    args: [account, operator]
+  });
+}
+function setApprovalForAll2(client, token, operator, approved) {
+  return client.writeContract({
+    address: token,
+    abi: ERC1155_ABI,
+    functionName: "setApprovalForAll",
+    args: [operator, approved],
+    account: client.account,
+    chain: client.chain
+  });
+}
+function safeTransferFrom2(client, token, from, to, id, amount, data = "0x") {
+  return client.writeContract({
+    address: token,
+    abi: ERC1155_ABI,
+    functionName: "safeTransferFrom",
+    args: [from, to, id, amount, data],
+    account: client.account,
+    chain: client.chain
+  });
+}
+function safeBatchTransferFrom(client, token, from, to, ids, amounts, data = "0x") {
+  return client.writeContract({
+    address: token,
+    abi: ERC1155_ABI,
+    functionName: "safeBatchTransferFrom",
+    args: [from, to, ids, amounts, data],
+    account: client.account,
+    chain: client.chain
+  });
+}
+var erc1155 = {
+  balanceOf: balanceOf3,
+  balanceOfBatch,
+  uri,
+  isApprovedForAll: isApprovedForAll2,
+  setApprovalForAll: setApprovalForAll2,
+  safeTransferFrom: safeTransferFrom2,
+  safeBatchTransferFrom
+};
+
+// src/fees.ts
+async function estimateEip1559Fees(client) {
+  const { maxFeePerGas, maxPriorityFeePerGas } = await client.estimateFeesPerGas();
+  return { maxFeePerGas, maxPriorityFeePerGas };
+}
+function gasPrice(client) {
+  return client.getGasPrice();
+}
+var fees = {
+  estimateEip1559Fees,
+  gasPrice
+};
+
+// src/contracts.ts
+function deployContract(client, { abi, bytecode, args }) {
+  return client.deployContract({
+    abi,
+    bytecode,
+    args,
+    account: client.account,
+    chain: client.chain
+  });
+}
+function readContract(client, params) {
+  return client.readContract(params);
+}
+function writeContract(client, params) {
+  const p = params;
+  return client.writeContract({
+    account: client.account,
+    chain: client.chain,
+    ...p
+  });
+}
+var PRECOMPILE_ADDRESSES = {
+  /** CrossVM Bridge precompile. */
+  crossVmBridge: "0x0000000000000000000000000000000000000901",
+  /** PQC signature verification (`IQorePQC.pqcVerify`). */
+  pqcVerify: "0x0000000000000000000000000000000000000A01",
+  /** PQC key registration status (`IQorePQC.pqcKeyStatus`). */
+  pqcKeyStatus: "0x0000000000000000000000000000000000000A02",
+  /** AI transaction risk score (`IQoreAI.aiRiskScore`). */
+  aiRiskScore: "0x0000000000000000000000000000000000000B01",
+  /** AI anomaly check (`IQoreAI.aiAnomalyCheck`). */
+  aiAnomalyCheck: "0x0000000000000000000000000000000000000B02",
+  /** Consensus parameters (`IQoreConsensus.rlConsensusParams`). */
+  rlConsensusParams: "0x0000000000000000000000000000000000000C01"
+};
+var addr = (a) => viem.getAddress(a);
+function pqcVerify(client, { pubkey, signature, message }) {
+  return client.readContract({
+    address: addr(PRECOMPILE_ADDRESSES.pqcVerify),
+    abi: IQORE_PQC_ABI,
+    functionName: "pqcVerify",
+    args: [pubkey, signature, message]
+  });
+}
+async function pqcKeyStatus(client, account) {
+  const [registered, algorithmId, pubkey] = await client.readContract({
+    address: addr(PRECOMPILE_ADDRESSES.pqcKeyStatus),
+    abi: IQORE_PQC_ABI,
+    functionName: "pqcKeyStatus",
+    args: [account]
+  });
+  return { registered, algorithmId, pubkey };
+}
+async function aiRiskScore(client, txData) {
+  const [score, level] = await client.readContract({
+    address: addr(PRECOMPILE_ADDRESSES.aiRiskScore),
+    abi: IQORE_AI_ABI,
+    functionName: "aiRiskScore",
+    args: [txData]
+  });
+  return { score, level };
+}
+async function aiAnomalyCheck(client, { sender, amount }) {
+  const [anomalyScore, flagged] = await client.readContract({
+    address: addr(PRECOMPILE_ADDRESSES.aiAnomalyCheck),
+    abi: IQORE_AI_ABI,
+    functionName: "aiAnomalyCheck",
+    args: [sender, amount]
+  });
+  return { anomalyScore, flagged };
+}
+async function rlConsensusParams(client) {
+  const [blockTime, baseGasPrice, validatorSetSize, epoch] = await client.readContract({
+    address: addr(PRECOMPILE_ADDRESSES.rlConsensusParams),
+    abi: IQORE_CONSENSUS_ABI,
+    functionName: "rlConsensusParams"
+  });
+  return { blockTime, baseGasPrice, validatorSetSize, epoch };
+}
+var precompiles = {
+  pqcVerify,
+  pqcKeyStatus,
+  aiRiskScore,
+  aiAnomalyCheck,
+  rlConsensusParams
+};
+function resolveProvider(provider) {
+  if (provider) return provider;
+  if (typeof window === "undefined") {
+    throw new Error(
+      "EVM wallet: no browser `window` available. Run in a browser, or pass `provider` explicitly."
+    );
+  }
+  const injected = window.ethereum;
+  if (!injected) {
+    throw new Error(
+      "EVM wallet: no injected EIP-1193 provider found (window.ethereum). Install MetaMask, or pass `provider`."
+    );
+  }
+  return injected;
+}
+function toHexChainId(chainId) {
+  return `0x${chainId.toString(16)}`;
+}
+async function requestAccounts(provider) {
+  const accounts = await provider.request({
+    method: "eth_requestAccounts"
+  });
+  if (!accounts || accounts.length === 0) {
+    throw new Error("EVM wallet: provider returned no accounts");
+  }
+  return accounts;
+}
+async function addQoreChainNetwork(provider, network, opts = {}) {
+  const chainId = opts.chainId ?? Number(await provider.request({ method: "eth_chainId" }));
+  await provider.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: toHexChainId(chainId),
+        chainName: network.coin.display === "QOR" ? "QoreChain EVM" : network.coin.display,
+        nativeCurrency: {
+          name: network.coin.display,
+          symbol: network.coin.display,
+          decimals: 18
+        },
+        rpcUrls: [network.endpoints.evmRpc],
+        ...opts.blockExplorerUrl ? { blockExplorerUrls: [opts.blockExplorerUrl] } : {}
+      }
+    ]
+  });
+}
+async function switchChain(provider, chainId) {
+  await provider.request({
+    method: "wallet_switchEthereumChain",
+    params: [{ chainId: toHexChainId(chainId) }]
+  });
+}
+async function getEvmWalletClient(opts = {}) {
+  const provider = resolveProvider(opts.provider);
+  const accounts = await requestAccounts(provider);
+  const address = accounts[0];
+  const chainId = opts.chainId ?? Number(await provider.request({ method: "eth_chainId" }));
+  const decimals = opts.decimals ?? 18;
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "QoreChain EVM",
+    nativeCurrency: { name: "QOR", symbol: "QOR", decimals },
+    rpcUrls: { default: { http: [] } }
+  });
+  const walletClient = viem.createWalletClient({
+    account: address,
+    chain,
+    transport: viem.custom(provider)
+  });
+  return { walletClient, address, provider, chain };
+}
+function discoverEvmProviders(timeoutMs = 200) {
+  if (typeof window === "undefined") return Promise.resolve([]);
+  return new Promise((resolve) => {
+    const found = /* @__PURE__ */ new Map();
+    const onAnnounce = (event) => {
+      const detail = event.detail;
+      if (detail?.info?.uuid) found.set(detail.info.uuid, detail);
+    };
+    window.addEventListener("eip6963:announceProvider", onAnnounce);
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+    setTimeout(() => {
+      window.removeEventListener(
+        "eip6963:announceProvider",
+        onAnnounce
+      );
+      resolve([...found.values()]);
+    }, timeoutMs);
+  });
+}
+function extractRevertData(err) {
+  const e = err;
+  const d = e?.data ?? e?.cause?.data;
+  if (typeof d === "string" && d.startsWith("0x")) return d;
+  if (d && typeof d === "object" && "data" in d) {
+    const inner = d.data;
+    if (typeof inner === "string" && inner.startsWith("0x")) return inner;
+  }
+  return void 0;
+}
+function decodeEvmError(error, abi) {
+  if (error instanceof viem.BaseError) {
+    const revert = error.walk(
+      (e) => e instanceof viem.ContractFunctionRevertedError
+    );
+    if (revert instanceof viem.ContractFunctionRevertedError) {
+      const data2 = revert.data;
+      if (data2?.errorName === "Error") {
+        const reason = data2.args?.[0] ?? revert.reason ?? "reverted";
+        return { message: `reverted: ${reason}`, kind: "revert", errorName: "Error" };
+      }
+      if (data2?.errorName === "Panic") {
+        return {
+          message: `panic: ${String(data2.args?.[0])}`,
+          kind: "panic",
+          errorName: "Panic",
+          args: data2.args
+        };
+      }
+      if (data2?.errorName) {
+        return {
+          message: `custom error ${data2.errorName}(${(data2.args ?? []).map((a) => String(a)).join(", ")})`,
+          kind: "custom_error",
+          errorName: data2.errorName,
+          args: data2.args
+        };
+      }
+      if (revert.reason) {
+        return { message: `reverted: ${revert.reason}`, kind: "revert" };
+      }
+    }
+    const data = extractRevertData(error);
+    if (data && abi) {
+      try {
+        const decoded = viem.decodeErrorResult({ abi, data });
+        return {
+          message: `custom error ${decoded.errorName}(${(decoded.args ?? []).map((a) => String(a)).join(", ")})`,
+          kind: "custom_error",
+          errorName: decoded.errorName,
+          args: decoded.args,
+          data
+        };
+      } catch {
+      }
+    }
+    const deepest = error.walk();
+    return {
+      message: deepest.shortMessage ?? error.shortMessage ?? error.message,
+      kind: "execution",
+      data
+    };
+  }
+  if (error instanceof Error) {
+    return { message: error.message, kind: "rpc" };
+  }
+  return { message: String(error), kind: "unknown" };
+}
+function resolveTransport(opts) {
+  if (opts.transport) return opts.transport;
+  const url = opts.wsUrl ?? opts.endpoints?.evmWs;
+  if (!url) {
+    throw new Error(
+      "createEvmSubscriptionClient: provide `wsUrl`, `endpoints.evmWs`, or a `transport`"
+    );
+  }
+  return viem.webSocket(url);
+}
+function createEvmSubscriptionClient(opts) {
+  const transport = resolveTransport(opts);
+  return viem.createPublicClient({ transport, chain: opts.chain });
+}
+function watchBlocks(client, args) {
+  return client.watchBlocks(args);
+}
+function watchEvent(client, args) {
+  return client.watchEvent(args);
+}
+function watchContractEvent(client, args) {
+  return client.watchContractEvent(args);
+}
+function watchPendingTransactions(client, args) {
+  return client.watchPendingTransactions(args);
+}
+
+// src/index.ts
+var VERSION = "0.3.0";
+
+exports.ERC1155_ABI = ERC1155_ABI;
+exports.ERC20_ABI = ERC20_ABI;
+exports.ERC721_ABI = ERC721_ABI;
+exports.IQORE_AI_ABI = IQORE_AI_ABI;
+exports.IQORE_CONSENSUS_ABI = IQORE_CONSENSUS_ABI;
+exports.IQORE_PQC_ABI = IQORE_PQC_ABI;
+exports.PRECOMPILE_ADDRESSES = PRECOMPILE_ADDRESSES;
+exports.VERSION = VERSION;
+exports.addQoreChainNetwork = addQoreChainNetwork;
+exports.aiAnomalyCheck = aiAnomalyCheck;
+exports.aiRiskScore = aiRiskScore;
+exports.allowance = allowance;
+exports.approve = approve;
+exports.balanceOf = balanceOf;
+exports.createEvmClient = createEvmClient;
+exports.createEvmSubscriptionClient = createEvmSubscriptionClient;
+exports.decodeEvmError = decodeEvmError;
+exports.deployContract = deployContract;
+exports.discoverEvmProviders = discoverEvmProviders;
+exports.erc1155 = erc1155;
+exports.erc20 = erc20;
+exports.erc721 = erc721;
+exports.estimateEip1559Fees = estimateEip1559Fees;
+exports.evmAccountFromPrivateKey = evmAccountFromPrivateKey;
+exports.fees = fees;
+exports.gasPrice = gasPrice;
+exports.getEvmWalletClient = getEvmWalletClient;
+exports.metadata = metadata;
+exports.pqcKeyStatus = pqcKeyStatus;
+exports.pqcVerify = pqcVerify;
+exports.precompiles = precompiles;
+exports.readContract = readContract;
+exports.requestAccounts = requestAccounts;
+exports.rlConsensusParams = rlConsensusParams;
+exports.switchChain = switchChain;
+exports.toHexChainId = toHexChainId;
+exports.transfer = transfer;
+exports.watchBlocks = watchBlocks;
+exports.watchContractEvent = watchContractEvent;
+exports.watchEvent = watchEvent;
+exports.watchPendingTransactions = watchPendingTransactions;
+exports.writeContract = writeContract;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map