@qorechain/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1252 @@
+'use strict';
+
+var stargate = require('@cosmjs/stargate');
+var protoSigning = require('@cosmjs/proto-signing');
+var tx = require('cosmjs-types/cosmos/bank/v1beta1/tx');
+var cosmwasmStargate = require('@cosmjs/cosmwasm-stargate');
+var bech32 = require('bech32');
+var bip39 = require('@scure/bip39');
+var english = require('@scure/bip39/wordlists/english');
+var bip32 = require('@scure/bip32');
+var slip10_js = require('micro-key-producer/slip10.js');
+var secp256k1 = require('@noble/curves/secp256k1');
+var sha256 = require('@noble/hashes/sha256');
+var ripemd160 = require('@noble/hashes/ripemd160');
+var sha3 = require('@noble/hashes/sha3');
+var base = require('@scure/base');
+var mlDsa_js = require('@noble/post-quantum/ml-dsa.js');
+var utils = require('@noble/hashes/utils');
+var any = require('cosmjs-types/google/protobuf/any');
+var tx$1 = require('cosmjs-types/cosmos/tx/v1beta1/tx');
+var amino = require('@cosmjs/amino');
+var signing = require('cosmjs-types/cosmos/tx/signing/v1beta1/signing');
+
+// src/config/networks.ts
+var BECH32 = {
+  account: "qor",
+  validator: "qorvaloper",
+  consensus: "qorvalcons"
+};
+var COIN = {
+  display: "QOR",
+  base: "uqor",
+  exponent: 6
+};
+var NETWORKS = {
+  testnet: {
+    name: "testnet",
+    live: true,
+    chainId: "qorechain-diana",
+    bech32: BECH32,
+    coin: COIN,
+    endpoints: {
+      rest: "http://localhost:1317",
+      grpc: "http://localhost:9090",
+      rpc: "http://localhost:26657",
+      evmRpc: "http://localhost:8545",
+      evmWs: "ws://localhost:8546",
+      svmRpc: "http://localhost:8899"
+    }
+  },
+  mainnet: {
+    name: "mainnet",
+    live: true,
+    chainId: "qorechain-vladi",
+    bech32: BECH32,
+    coin: COIN,
+    endpoints: {
+      rest: "http://localhost:1317",
+      grpc: "http://localhost:9090",
+      rpc: "http://localhost:26657",
+      evmRpc: "http://localhost:8545",
+      evmWs: "ws://localhost:8546",
+      svmRpc: "http://localhost:8899"
+    }
+  }
+};
+function getNetwork(name) {
+  return NETWORKS[name];
+}
+function listNetworks() {
+  return Object.keys(NETWORKS);
+}
+
+// src/query/http.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRIES = 2;
+var DEFAULT_RETRY_DELAY_MS = 250;
+var QoreHttpError = class _QoreHttpError extends Error {
+  constructor(status, url, body) {
+    super(`HTTP ${status} for ${url}`);
+    this.name = "QoreHttpError";
+    this.status = status;
+    this.url = url;
+    this.body = body;
+    Object.setPrototypeOf(this, _QoreHttpError.prototype);
+  }
+};
+function resolveFetch(opts) {
+  const f = opts?.fetch ?? globalThis.fetch;
+  if (!f) {
+    throw new Error(
+      "no fetch implementation available \u2014 pass `fetch` in the client options"
+    );
+  }
+  return f;
+}
+function buildUrl(base, query) {
+  if (!query) return base;
+  const parts = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  if (parts.length === 0) return base;
+  const sep = base.includes("?") ? "&" : "?";
+  return `${base}${sep}${parts.join("&")}`;
+}
+function joinUrl(base, path) {
+  const left = base.replace(/\/+$/, "");
+  const right = path.replace(/^\/+/, "");
+  return `${left}/${right}`;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableStatus(status) {
+  return status >= 500 && status < 600;
+}
+async function attempt(url, init, fetchImpl, timeoutMs) {
+  const controller = timeoutMs > 0 ? new AbortController() : void 0;
+  const timer = controller && timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+  try {
+    const res = await fetchImpl(url, {
+      ...init,
+      signal: controller?.signal
+    });
+    if (!res.ok) {
+      let body;
+      try {
+        body = await res.text();
+      } catch {
+        body = void 0;
+      }
+      throw new QoreHttpError(res.status, url, body);
+    }
+    return await res.json();
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function withRetry(url, init, opts) {
+  const fetchImpl = resolveFetch(opts);
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const retries = opts?.retries ?? DEFAULT_RETRIES;
+  const retryDelayMs = opts?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  let lastError;
+  for (let i = 0; i <= retries; i++) {
+    try {
+      return await attempt(url, init, fetchImpl, timeoutMs);
+    } catch (err) {
+      lastError = err;
+      const retryable = err instanceof QoreHttpError ? isRetryableStatus(err.status) : true;
+      if (!retryable || i === retries) throw err;
+      if (retryDelayMs > 0) await delay(retryDelayMs);
+    }
+  }
+  throw lastError;
+}
+function getJson(url, opts) {
+  const fullUrl = buildUrl(url, opts?.query);
+  const init = {
+    method: "GET",
+    headers: { accept: "application/json", ...opts?.headers ?? {} }
+  };
+  return withRetry(fullUrl, init, opts);
+}
+function postJsonRpc(url, body, opts) {
+  const init = {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json",
+      ...opts?.headers ?? {}
+    },
+    body: JSON.stringify(body)
+  };
+  return withRetry(url, init, opts);
+}
+
+// src/query/rest.ts
+function paginationQuery(p) {
+  const q = {};
+  if (p?.key !== void 0) q["pagination.key"] = p.key;
+  if (p?.limit !== void 0) q["pagination.limit"] = p.limit;
+  return q;
+}
+var RestClient = class {
+  /**
+   * @param baseUrl - The network's REST endpoint (e.g. `endpoints.rest`).
+   * @param opts - Injectable `fetch`, timeout, and retry settings.
+   */
+  constructor(baseUrl, opts = {}) {
+    this.baseUrl = baseUrl;
+    this.opts = opts;
+  }
+  /** Injectable fetch passthrough so the escape hatch reuses the same transport. */
+  get fetchImpl() {
+    return this.opts.fetch;
+  }
+  /**
+   * Generic GET escape hatch for any documented REST route.
+   *
+   * @param path - Path beginning with `/` (e.g. `/qorechain/foo/v1/bar`).
+   *   Embedded path params must be URL-encoded by the caller.
+   * @param query - Optional query parameters.
+   */
+  get(path, query) {
+    return getJson(joinUrl(this.baseUrl, path), {
+      ...this.opts,
+      query
+    });
+  }
+  // --- Standard Cosmos bank ------------------------------------------------
+  /** All balances of `address` (`/cosmos/bank/v1beta1/balances/{address}`). */
+  getAllBalances(address, opts) {
+    return this.get(
+      `/cosmos/bank/v1beta1/balances/${encodeURIComponent(address)}`,
+      paginationQuery(opts?.pagination)
+    );
+  }
+  /** Balance of `address` in `denom` (`.../balances/{address}/by_denom`). */
+  getBalance(address, denom) {
+    return this.get(
+      `/cosmos/bank/v1beta1/balances/${encodeURIComponent(address)}/by_denom`,
+      { denom }
+    );
+  }
+  // --- Custom QoreChain module reads ---------------------------------------
+  /** QCAI fee/network stats (`/qorechain/ai/v1/stats`). */
+  getAiStats() {
+    return this.get("/qorechain/ai/v1/stats");
+  }
+  /** QCAI fee estimate for an urgency level (`/qorechain/ai/v1/fee-estimate`). */
+  getFeeEstimate(urgency) {
+    return this.get("/qorechain/ai/v1/fee-estimate", { urgency });
+  }
+  /** Supported bridge chains (`/qorechain/bridge/v1/chains`). */
+  getBridgeChains() {
+    return this.get("/qorechain/bridge/v1/chains");
+  }
+  /** PQC account record (`/qorechain/pqc/v1/accounts/{address}`). */
+  getPqcAccount(address) {
+    return this.get(`/qorechain/pqc/v1/accounts/${encodeURIComponent(address)}`);
+  }
+  /** Validator reputation (`/qorechain/reputation/v1/validators/{address}`). */
+  getReputation(validatorAddress) {
+    return this.get(
+      `/qorechain/reputation/v1/validators/${encodeURIComponent(validatorAddress)}`
+    );
+  }
+  /** Token burn statistics (`/qorechain/burn/v1/stats`). */
+  getBurnStats() {
+    return this.get("/qorechain/burn/v1/stats");
+  }
+  /** xQORE staking position (`/qorechain/xqore/v1/position/{address}`). */
+  getXqorePosition(address) {
+    return this.get(`/qorechain/xqore/v1/position/${encodeURIComponent(address)}`);
+  }
+  /** Current inflation rate (`/qorechain/inflation/v1/rate`). */
+  getInflationRate() {
+    return this.get("/qorechain/inflation/v1/rate");
+  }
+};
+
+// src/query/jsonrpc.ts
+var JsonRpcError = class _JsonRpcError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.name = "JsonRpcError";
+    this.code = code;
+    this.data = data;
+    Object.setPrototypeOf(this, _JsonRpcError.prototype);
+  }
+};
+var JsonRpcClient = class {
+  constructor(url, opts = {}) {
+    this.nextId = 1;
+    this.url = url;
+    this.opts = opts;
+  }
+  /**
+   * Invoke a JSON-RPC method and return its `result`.
+   *
+   * @param method - Wire method name (e.g. `"eth_chainId"`).
+   * @param params - Positional params; defaults to an empty array.
+   * @throws {@link JsonRpcError} when the response contains an `error`.
+   * @throws {@link QoreHttpError} on a non-2xx transport response.
+   */
+  async call(method, params = []) {
+    const id = this.nextId++;
+    const body = { jsonrpc: "2.0", id, method, params };
+    const res = await postJsonRpc(this.url, body, this.opts);
+    if (res.error) {
+      throw new JsonRpcError(res.error.code, res.error.message, res.error.data);
+    }
+    return res.result;
+  }
+  /** `eth_chainId` — the chain id as a hex quantity string. */
+  ethChainId() {
+    return this.call("eth_chainId", []);
+  }
+  /** `eth_blockNumber` — the latest block height as a hex quantity string. */
+  ethBlockNumber() {
+    return this.call("eth_blockNumber", []);
+  }
+  /** `eth_getBalance` — wei balance of `address` as a hex quantity string. */
+  ethGetBalance(address, block = "latest") {
+    return this.call("eth_getBalance", [address, block]);
+  }
+  /** `net_version` — the network id as a decimal string. */
+  netVersion() {
+    return this.call("net_version", []);
+  }
+  /** `web3_clientVersion` — the node client version string. */
+  web3ClientVersion() {
+    return this.call("web3_clientVersion", []);
+  }
+};
+
+// src/query/qor.ts
+var QorClient = class extends JsonRpcClient {
+  constructor(url, opts = {}) {
+    super(url, opts);
+  }
+  /** `qor_getPQCKeyStatus` — PQC key registration status for an address. */
+  getPqcKeyStatus(address) {
+    return this.call("qor_getPQCKeyStatus", [address]);
+  }
+  /** `qor_getHybridSignatureMode` — active hybrid-signature policy. */
+  getHybridSignatureMode() {
+    return this.call("qor_getHybridSignatureMode", []);
+  }
+  /** `qor_getAIStats` — QCAI engine statistics. */
+  getAiStats() {
+    return this.call("qor_getAIStats", []);
+  }
+  /** `qor_getCrossVMMessage` — a cross-VM message by id. */
+  getCrossVmMessage(messageId) {
+    return this.call("qor_getCrossVMMessage", [messageId]);
+  }
+  /** `qor_getReputationScore` — reputation score for a validator. */
+  getReputationScore(validator) {
+    return this.call("qor_getReputationScore", [validator]);
+  }
+  /** `qor_getLayerInfo` — info about a chain layer. */
+  getLayerInfo(layerId) {
+    return this.call("qor_getLayerInfo", [layerId]);
+  }
+  /** `qor_getBridgeStatus` — bridge status for a remote chain id. */
+  getBridgeStatus(chainId) {
+    return this.call("qor_getBridgeStatus", [chainId]);
+  }
+  /** `qor_getRLAgentStatus` — reinforcement-learning agent status. */
+  getRlAgentStatus() {
+    return this.call("qor_getRLAgentStatus", []);
+  }
+  /** `qor_getRLObservation` — latest RL observation vector. */
+  getRlObservation() {
+    return this.call("qor_getRLObservation", []);
+  }
+  /** `qor_getRLReward` — latest RL reward signal. */
+  getRlReward() {
+    return this.call("qor_getRLReward", []);
+  }
+  /** `qor_getPoolClassification` — validator pool classification. */
+  getPoolClassification(validator) {
+    return this.call("qor_getPoolClassification", [validator]);
+  }
+  /** `qor_getBurnStats` — token burn statistics. */
+  getBurnStats() {
+    return this.call("qor_getBurnStats", []);
+  }
+  /** `qor_getXQOREPosition` — xQORE staking position for an address. */
+  getXqorePosition(address) {
+    return this.call("qor_getXQOREPosition", [address]);
+  }
+  /** `qor_getInflationRate` — current inflation rate. */
+  getInflationRate() {
+    return this.call("qor_getInflationRate", []);
+  }
+  /** `qor_getTokenomicsOverview` — aggregate tokenomics snapshot. */
+  getTokenomicsOverview() {
+    return this.call("qor_getTokenomicsOverview", []);
+  }
+  /** `qor_getRollupStatus` — status of a rollup. */
+  getRollupStatus(rollupId) {
+    return this.call("qor_getRollupStatus", [rollupId]);
+  }
+  /** `qor_listRollups` — all known rollups. */
+  listRollups() {
+    return this.call("qor_listRollups", []);
+  }
+  /** `qor_getSettlementBatch` — a settlement batch by rollup and index. */
+  getSettlementBatch(rollupId, batchIndex) {
+    return this.call("qor_getSettlementBatch", [rollupId, batchIndex]);
+  }
+  /** `qor_suggestRollupProfile` — a suggested rollup profile for a use case. */
+  suggestRollupProfile(useCase) {
+    return this.call("qor_suggestRollupProfile", [useCase]);
+  }
+  /** `qor_getDABlobStatus` — data-availability blob status by rollup and index. */
+  getDaBlobStatus(rollupId, blobIndex) {
+    return this.call("qor_getDABlobStatus", [rollupId, blobIndex]);
+  }
+  /** `qor_getBTCStakingPosition` — BTC staking position for an address. */
+  getBtcStakingPosition(address) {
+    return this.call("qor_getBTCStakingPosition", [address]);
+  }
+  /** `qor_getAbstractAccount` — account-abstraction record for an address. */
+  getAbstractAccount(address) {
+    return this.call("qor_getAbstractAccount", [address]);
+  }
+  /** `qor_getFairBlockStatus` — fair-ordering / fair-block status. */
+  getFairBlockStatus() {
+    return this.call("qor_getFairBlockStatus", []);
+  }
+  /** `qor_getGasAbstractionConfig` — gas-abstraction configuration. */
+  getGasAbstractionConfig() {
+    return this.call("qor_getGasAbstractionConfig", []);
+  }
+  /** `qor_getLaneConfiguration` — mempool lane configuration. */
+  getLaneConfiguration() {
+    return this.call("qor_getLaneConfiguration", []);
+  }
+};
+
+// src/tx/fees.ts
+var STATIC_FALLBACK = {
+  /** Fallback gas price, in base denom per unit of gas. */
+  gasPrice: "0.025",
+  /** Base denomination fees are paid in. */
+  denom: "uqor",
+  /** Default gas limit when the caller does not supply one. */
+  gas: "200000"
+};
+function gasString(gas) {
+  if (gas === void 0) return STATIC_FALLBACK.gas;
+  return typeof gas === "number" ? Math.ceil(gas).toString() : gas;
+}
+function staticFee(gas, gasPrice, denom) {
+  const gasUnits = BigInt(gas);
+  const [intPart, fracPart = ""] = gasPrice.split(".");
+  const scale = 10n ** BigInt(fracPart.length);
+  const numerator = BigInt(intPart || "0") * scale + BigInt(fracPart || "0");
+  const raw = gasUnits * numerator;
+  const amount = (raw + scale - 1n) / scale;
+  return { amount: [{ denom, amount: amount.toString() }], gas };
+}
+async function estimateFee(rest, opts = {}) {
+  const urgency = opts.urgency ?? "normal";
+  const gas = gasString(opts.gas);
+  const denom = opts.denom ?? STATIC_FALLBACK.denom;
+  const fallbackGasPrice = opts.fallbackGasPrice ?? STATIC_FALLBACK.gasPrice;
+  try {
+    const res = await rest.getFeeEstimate(urgency);
+    const suggested = res?.suggested_fee_uqor;
+    if (suggested !== void 0 && suggested !== null) {
+      const amount = typeof suggested === "number" ? Math.ceil(suggested).toString() : suggested;
+      if (amount !== "" && amount !== "0") {
+        return { amount: [{ denom, amount }], gas };
+      }
+    }
+  } catch {
+  }
+  return staticFee(gas, fallbackGasPrice, denom);
+}
+var MSG_SEND_TYPE_URL = "/cosmos.bank.v1beta1.MsgSend";
+var TxClient = class _TxClient {
+  constructor(opts) {
+    this.client = opts.signingClient;
+    this.senderAddress = opts.senderAddress;
+  }
+  /**
+   * Connect to a network's consensus RPC and build a {@link TxClient}.
+   *
+   * Resolves the signer's first account as the sender address and merges any
+   * `registryTypes` into cosmjs's default message registry.
+   */
+  static async connect(opts) {
+    const registry = new protoSigning.Registry(stargate.defaultRegistryTypes);
+    for (const [typeUrl, type] of opts.registryTypes ?? []) {
+      registry.register(typeUrl, type);
+    }
+    const client = await stargate.SigningStargateClient.connectWithSigner(
+      opts.rpcEndpoint,
+      opts.signer,
+      { registry, ...opts.clientOptions }
+    );
+    const accounts = await opts.signer.getAccounts();
+    if (accounts.length === 0) {
+      throw new Error("signer exposes no accounts");
+    }
+    return new _TxClient({
+      signingClient: client,
+      senderAddress: accounts[0].address
+    });
+  }
+  /**
+   * Simulate the given messages and return the estimated gas units.
+   *
+   * Use the result (with a safety multiplier) as the `gas` for `estimateFee`.
+   */
+  simulate(messages, opts = {}) {
+    return this.client.simulate(this.senderAddress, messages, opts.memo);
+  }
+  /**
+   * Sign and broadcast the given messages with an explicit fee.
+   *
+   * Broadcast mode maps onto cosmjs transports:
+   * - `commit` (default): polls until the tx lands in a block; returns the full
+   *   result and throws on a non-zero delivery code.
+   * - `sync` / `async`: returns after mempool submission with just the tx hash.
+   */
+  async signAndBroadcast(messages, fee, memo = "", opts = {}) {
+    const mode = opts.mode ?? "commit";
+    if (mode === "commit") {
+      const res = await this.client.signAndBroadcast(
+        this.senderAddress,
+        messages,
+        fee,
+        memo
+      );
+      if (res.code !== 0) {
+        throw new Error(
+          `transaction failed with code ${res.code}: ${res.rawLog ?? "(no log)"} (hash ${res.transactionHash})`
+        );
+      }
+      return {
+        transactionHash: res.transactionHash,
+        code: res.code,
+        height: res.height,
+        gasUsed: res.gasUsed,
+        gasWanted: res.gasWanted,
+        rawLog: res.rawLog
+      };
+    }
+    const hash = await this.client.signAndBroadcastSync(
+      this.senderAddress,
+      messages,
+      fee,
+      memo
+    );
+    return { transactionHash: hash, code: 0 };
+  }
+  /**
+   * Send `amount` to `toAddress` via a bank `MsgSend`, then broadcast.
+   *
+   * Constructs `/cosmos.bank.v1beta1.MsgSend` from this client's sender address.
+   */
+  bankSend(toAddress, amount, opts) {
+    const msg = {
+      typeUrl: MSG_SEND_TYPE_URL,
+      value: tx.MsgSend.fromPartial({
+        fromAddress: this.senderAddress,
+        toAddress,
+        amount
+      })
+    };
+    return this.signAndBroadcast([msg], opts.fee, opts.memo ?? "", {
+      mode: opts.mode
+    });
+  }
+  /** Disconnect the underlying client's transport, if it supports it. */
+  disconnect() {
+    this.client.disconnect?.();
+  }
+};
+function createCosmWasmClient(rpcUrl) {
+  return cosmwasmStargate.CosmWasmClient.connect(rpcUrl);
+}
+function connectCosmWasmSigner(rpcUrl, signer) {
+  return cosmwasmStargate.SigningCosmWasmClient.connectWithSigner(rpcUrl, signer);
+}
+function queryContractSmart(client, contractAddress, queryMsg) {
+  return client.queryContractSmart(contractAddress, queryMsg);
+}
+function getContractInfo(client, contractAddress) {
+  return client.getContract(contractAddress);
+}
+function instantiate(client, sender, codeId, initMsg, label, opts = {}) {
+  const { fee = "auto", memo, funds, admin } = opts;
+  const options = {};
+  if (funds !== void 0) options.funds = funds;
+  if (admin !== void 0) options.admin = admin;
+  if (memo !== void 0) options.memo = memo;
+  return client.instantiate(
+    sender,
+    codeId,
+    initMsg,
+    label,
+    fee,
+    options
+  );
+}
+function execute(client, sender, contractAddress, msg, fee, funds) {
+  return client.execute(
+    sender,
+    contractAddress,
+    msg,
+    fee,
+    void 0,
+    funds
+  );
+}
+function uploadCode(client, sender, wasmBytes, fee) {
+  return client.upload(sender, wasmBytes, fee);
+}
+
+// src/query/crossvm.ts
+function getCrossVmMessage(rest, id) {
+  return rest.get(
+    `/qorechain/crossvm/v1/message/${encodeURIComponent(id)}`
+  );
+}
+function getPendingCrossVmMessages(rest) {
+  return rest.get("/qorechain/crossvm/v1/pending");
+}
+function getCrossVmParams(rest) {
+  return rest.get("/qorechain/crossvm/v1/params");
+}
+
+// src/client.ts
+function resolveNetwork(opts) {
+  const name = opts.network ?? "testnet";
+  const overrides = opts.endpoints ?? {};
+  const base = getNetwork(name);
+  return {
+    ...base,
+    chainId: opts.chainId ?? base.chainId,
+    endpoints: { ...base.endpoints, ...overrides }
+  };
+}
+function requireEndpoint(endpoints, key) {
+  const value = endpoints?.[key];
+  if (!value) {
+    throw new Error(
+      `endpoint "${key}" is not configured \u2014 pass it via createClient({ endpoints: { ${key}: "..." } })`
+    );
+  }
+  return value;
+}
+function createClient(opts = {}) {
+  const network = resolveNetwork(opts);
+  const httpOptions = { ...opts.http, fetch: opts.fetch };
+  let restClient;
+  let evmClient;
+  let qorClient;
+  const getRest = () => {
+    if (!restClient) {
+      restClient = new RestClient(
+        requireEndpoint(network.endpoints, "rest"),
+        httpOptions
+      );
+    }
+    return restClient;
+  };
+  const getEvm = () => {
+    if (!evmClient) {
+      evmClient = new JsonRpcClient(
+        requireEndpoint(network.endpoints, "evmRpc"),
+        httpOptions
+      );
+    }
+    return evmClient;
+  };
+  const getQor = () => {
+    if (!qorClient) {
+      qorClient = new QorClient(
+        requireEndpoint(network.endpoints, "evmRpc"),
+        httpOptions
+      );
+    }
+    return qorClient;
+  };
+  const fees = {
+    estimate: (urgency) => estimateFee(getRest(), { urgency })
+  };
+  const crossvm = {
+    message: (id) => getCrossVmMessage(getRest(), id),
+    pending: () => getPendingCrossVmMessages(getRest()),
+    params: () => getCrossVmParams(getRest())
+  };
+  let cosmWasmClient;
+  return {
+    network,
+    get rest() {
+      return getRest();
+    },
+    get evm() {
+      return getEvm();
+    },
+    get qor() {
+      return getQor();
+    },
+    fees,
+    crossvm,
+    cosmwasm() {
+      if (!cosmWasmClient) {
+        cosmWasmClient = createCosmWasmClient(
+          requireEndpoint(network.endpoints, "rpc")
+        );
+      }
+      return cosmWasmClient;
+    },
+    connectTx(signer, txOpts = {}) {
+      return TxClient.connect({
+        rpcEndpoint: requireEndpoint(network.endpoints, "rpc"),
+        signer,
+        registryTypes: txOpts.registryTypes
+      });
+    }
+  };
+}
+
+// src/utils/denom.ts
+var DEFAULT_EXPONENT = 6;
+function resolveExponent(opts) {
+  const exponent = opts?.exponent ?? DEFAULT_EXPONENT;
+  if (!Number.isInteger(exponent) || exponent < 0) {
+    throw new Error(`invalid exponent: ${exponent} (must be a non-negative integer)`);
+  }
+  return exponent;
+}
+function toBase(amount, opts) {
+  const exponent = resolveExponent(opts);
+  const trimmed = amount.trim();
+  let body = trimmed;
+  if (body.startsWith("-")) {
+    throw new Error(`negative amounts are not supported: ${amount}`);
+  }
+  if (body.startsWith("+")) {
+    body = body.slice(1);
+  }
+  if (!/^\d+(\.\d+)?$/.test(body)) {
+    throw new Error(`invalid decimal amount: ${amount}`);
+  }
+  const [intPart, fracPart = ""] = body.split(".");
+  if (fracPart.length > exponent) {
+    throw new Error(
+      `too many decimal places in ${amount}: ${fracPart.length} > exponent ${exponent}`
+    );
+  }
+  const padded = fracPart.padEnd(exponent, "0");
+  const base = BigInt(intPart + padded);
+  return base.toString();
+}
+function fromBase(base, opts) {
+  const exponent = resolveExponent(opts);
+  const trimmed = base.trim();
+  if (trimmed.startsWith("-")) {
+    throw new Error(`negative amounts are not supported: ${base}`);
+  }
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`invalid base amount: ${base}`);
+  }
+  if (exponent === 0) {
+    return BigInt(trimmed).toString();
+  }
+  const padded = trimmed.padStart(exponent + 1, "0");
+  const intPart = padded.slice(0, padded.length - exponent);
+  const fracPart = padded.slice(padded.length - exponent);
+  const normalizedInt = BigInt(intPart).toString();
+  const trimmedFrac = fracPart.replace(/0+$/, "");
+  return trimmedFrac.length > 0 ? `${normalizedInt}.${trimmedFrac}` : normalizedInt;
+}
+var DEFAULT_PREFIX = "qor";
+var LIMIT = 1023;
+function stripHexPrefix(hex) {
+  return hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+}
+function hexToBytes(hex) {
+  const body = stripHexPrefix(hex);
+  if (body.length === 0 || body.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(body)) {
+    throw new Error(`invalid hex string: ${hex}`);
+  }
+  const bytes = new Uint8Array(body.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(body.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  let out = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    out += bytes[i].toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function bech32ToHex(addr) {
+  const { words } = bech32.bech32.decode(addr, LIMIT);
+  const bytes = bech32.bech32.fromWords(words);
+  return bytesToHex(bytes);
+}
+function bytesToBech32(bytes, prefix = DEFAULT_PREFIX) {
+  const words = bech32.bech32.toWords(bytes);
+  return bech32.bech32.encode(prefix, words, LIMIT);
+}
+function hexToBech32(hex, prefix = DEFAULT_PREFIX) {
+  return bytesToBech32(hexToBytes(hex), prefix);
+}
+function isValidBech32(addr, prefix) {
+  const decoded = bech32.bech32.decodeUnsafe(addr, LIMIT);
+  if (!decoded) {
+    return false;
+  }
+  return prefix === void 0 ? true : decoded.prefix === prefix;
+}
+var NATIVE_PREFIX = "qor";
+var COIN_TYPE_NATIVE = 118;
+var COIN_TYPE_EVM = 60;
+var COIN_TYPE_SVM = 501;
+function generateMnemonic(strength = 128) {
+  return bip39.generateMnemonic(english.wordlist, strength);
+}
+function validateMnemonic(mnemonic) {
+  return bip39.validateMnemonic(mnemonic, english.wordlist);
+}
+function addressIndex(opts) {
+  const index = opts?.accountIndex ?? 0;
+  if (!Number.isInteger(index) || index < 0) {
+    throw new Error(`accountIndex must be a non-negative integer, got ${index}`);
+  }
+  return index;
+}
+async function seedFromMnemonic(mnemonic) {
+  if (!validateMnemonic(mnemonic)) {
+    throw new Error("invalid mnemonic");
+  }
+  return bip39.mnemonicToSeed(mnemonic);
+}
+async function deriveSecp256k1(mnemonic, coinType, index) {
+  const seed = await seedFromMnemonic(mnemonic);
+  const node = bip32.HDKey.fromMasterSeed(seed).derive(
+    `m/44'/${coinType}'/0'/0/${index}`
+  );
+  if (!node.privateKey || !node.publicKey) {
+    throw new Error("failed to derive secp256k1 key from mnemonic");
+  }
+  return { privateKey: node.privateKey, publicKey: node.publicKey };
+}
+function toEip55Checksum(addressBytes) {
+  const lowerHex = Array.from(addressBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const hashHex = Array.from(sha3.keccak_256(new TextEncoder().encode(lowerHex))).map((b) => b.toString(16).padStart(2, "0")).join("");
+  let out = "0x";
+  for (let i = 0; i < lowerHex.length; i++) {
+    const c = lowerHex[i];
+    out += parseInt(hashHex[i], 16) >= 8 ? c.toUpperCase() : c;
+  }
+  return out;
+}
+async function deriveNativeAccount(mnemonic, opts) {
+  const index = addressIndex(opts);
+  const { privateKey, publicKey } = await deriveSecp256k1(
+    mnemonic,
+    COIN_TYPE_NATIVE,
+    index
+  );
+  const digest = ripemd160.ripemd160(sha256.sha256(publicKey));
+  const address = bytesToBech32(digest, NATIVE_PREFIX);
+  return { type: "native", address, publicKey, privateKey };
+}
+async function deriveEvmAccount(mnemonic, opts) {
+  const index = addressIndex(opts);
+  const { privateKey, publicKey } = await deriveSecp256k1(
+    mnemonic,
+    COIN_TYPE_EVM,
+    index
+  );
+  const uncompressed = secp256k1.secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(
+    false
+  );
+  const hash = sha3.keccak_256(uncompressed.slice(1));
+  const addressBytes = hash.slice(-20);
+  const address = toEip55Checksum(addressBytes);
+  return { type: "evm", address, publicKey, privateKey };
+}
+async function deriveSvmAccount(mnemonic, opts) {
+  const index = addressIndex(opts);
+  const seed = await seedFromMnemonic(mnemonic);
+  const node = slip10_js.HDKey.fromMasterSeed(seed).derive(
+    `m/44'/${COIN_TYPE_SVM}'/${index}'/0'`
+  );
+  const publicKey = node.publicKeyRaw;
+  const secretKey = new Uint8Array(64);
+  secretKey.set(node.privateKey, 0);
+  secretKey.set(publicKey, 32);
+  const address = base.base58.encode(publicKey);
+  return { type: "svm", address, publicKey, secretKey };
+}
+
+// src/accounts/pqc-algorithm.ts
+var AlgorithmUnspecified = 0;
+var AlgorithmDilithium5 = 1;
+var AlgorithmMLKEM1024 = 2;
+function algorithmName(id) {
+  switch (id) {
+    case AlgorithmUnspecified:
+      return "unspecified";
+    case AlgorithmDilithium5:
+      return "dilithium5";
+    case AlgorithmMLKEM1024:
+      return "mlkem1024";
+    default:
+      return `algorithm_${id}`;
+  }
+}
+function isSignatureAlgorithm(id) {
+  return id === AlgorithmDilithium5;
+}
+
+// src/accounts/pqc.ts
+var ML_DSA_87_PUBLIC_KEY_LENGTH = 2592;
+var ML_DSA_87_SECRET_KEY_LENGTH = 4896;
+var ML_DSA_87_SIGNATURE_LENGTH = 4627;
+var ML_DSA_87_SEED_LENGTH = 32;
+var HYBRID_SIG_TYPE_URL = "/qorechain.pqc.v1.PQCHybridSignature";
+function generatePqcKeypair(seed) {
+  if (seed !== void 0 && seed.length !== ML_DSA_87_SEED_LENGTH) {
+    throw new Error(
+      `ML-DSA-87 seed must be ${ML_DSA_87_SEED_LENGTH} bytes, got ${seed.length}`
+    );
+  }
+  const xi = seed ?? utils.randomBytes(ML_DSA_87_SEED_LENGTH);
+  const kp = mlDsa_js.ml_dsa87.keygen(xi);
+  return { publicKey: kp.publicKey, secretKey: kp.secretKey };
+}
+function pqcSign(secretKey, message) {
+  return mlDsa_js.ml_dsa87.sign(secretKey, message);
+}
+function pqcVerify(publicKey, message, signature) {
+  return mlDsa_js.ml_dsa87.verify(publicKey, message, signature);
+}
+function buildHybridSignatureExtension(args) {
+  const { algorithmId, signature, publicKey } = args;
+  if (!isSignatureAlgorithm(algorithmId)) {
+    throw new Error(
+      `algorithm ${algorithmName(algorithmId)} is not a PQC signature algorithm`
+    );
+  }
+  if (signature.length === 0) {
+    throw new Error("PQC signature cannot be empty");
+  }
+  if (algorithmId === AlgorithmDilithium5) {
+    if (signature.length !== ML_DSA_87_SIGNATURE_LENGTH) {
+      throw new Error(
+        `dilithium5 signature must be ${ML_DSA_87_SIGNATURE_LENGTH} bytes, got ${signature.length}`
+      );
+    }
+    if (publicKey !== void 0 && publicKey.length !== ML_DSA_87_PUBLIC_KEY_LENGTH) {
+      throw new Error(
+        `dilithium5 public key must be ${ML_DSA_87_PUBLIC_KEY_LENGTH} bytes, got ${publicKey.length}`
+      );
+    }
+  }
+  const ext = {
+    algorithm_id: algorithmId,
+    pqc_signature: signature
+  };
+  if (publicKey !== void 0) {
+    ext.pqc_public_key = publicKey;
+  }
+  return ext;
+}
+var PqcSigner = class {
+  constructor(keypair, algorithmId = AlgorithmDilithium5) {
+    this.mode = "pqc";
+    this.keypair = keypair;
+    this.algorithmId = algorithmId;
+  }
+  /** The PQC public key (the signing identity in pqc-only mode). */
+  publicKey() {
+    return this.keypair.publicKey;
+  }
+  async sign(message) {
+    const part = {
+      algorithmId: this.algorithmId,
+      signature: pqcSign(this.keypair.secretKey, message),
+      publicKey: this.keypair.publicKey
+    };
+    return { pqc: part };
+  }
+};
+var HybridSigner = class {
+  /**
+   * @param classical The wrapped classical signer. Must be a `classical`-mode
+   *   signer; its `classicalSignature` output is passed through unchanged.
+   * @param keypair The ML-DSA-87 keypair used for the PQC half.
+   * @throws if `classical` is not a `classical`-mode signer.
+   */
+  constructor(classical, keypair, algorithmId = AlgorithmDilithium5) {
+    this.mode = "hybrid";
+    if (classical.mode !== "classical") {
+      throw new Error("HybridSigner requires a classical-mode signer");
+    }
+    this.classical = classical;
+    this.keypair = keypair;
+    this.algorithmId = algorithmId;
+  }
+  /** The classical public key — the on-chain account identity. */
+  publicKey() {
+    return this.classical.publicKey();
+  }
+  async sign(message) {
+    const classicalOut = await this.classical.sign(message);
+    if (classicalOut.classicalSignature === void 0) {
+      throw new Error(
+        "wrapped classical signer did not produce a classical signature"
+      );
+    }
+    const part = {
+      algorithmId: this.algorithmId,
+      signature: pqcSign(this.keypair.secretKey, message),
+      publicKey: this.keypair.publicKey
+    };
+    return { classicalSignature: classicalOut.classicalSignature, pqc: part };
+  }
+};
+async function directSignerFromPrivateKey(privateKey, prefix) {
+  if (privateKey.length !== 32) {
+    throw new Error(
+      `secp256k1 private key must be 32 bytes, got ${privateKey.length}`
+    );
+  }
+  return protoSigning.DirectSecp256k1Wallet.fromKey(privateKey, prefix);
+}
+function toGoJson(ext) {
+  const obj = {
+    algorithm_id: ext.algorithm_id,
+    pqc_signature: base64(ext.pqc_signature)
+  };
+  if (ext.pqc_public_key !== void 0 && ext.pqc_public_key.length > 0) {
+    obj.pqc_public_key = base64(ext.pqc_public_key);
+  }
+  return JSON.stringify(obj);
+}
+function base64(bytes) {
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary);
+}
+function encodeHybridExtension(ext) {
+  const value = new TextEncoder().encode(toGoJson(ext));
+  return any.Any.fromPartial({ typeUrl: HYBRID_SIG_TYPE_URL, value });
+}
+function attachHybridExtension(body, ext, opts = {}) {
+  const anyExt = encodeHybridExtension(ext);
+  const placement = opts.placement ?? "non_critical_extension_options";
+  const next = tx$1.TxBody.fromPartial({
+    messages: body.messages,
+    memo: body.memo,
+    timeoutHeight: body.timeoutHeight,
+    extensionOptions: [...body.extensionOptions],
+    nonCriticalExtensionOptions: [...body.nonCriticalExtensionOptions]
+  });
+  if (placement === "extension_options") {
+    next.extensionOptions.push(anyExt);
+  } else {
+    next.nonCriticalExtensionOptions.push(anyExt);
+  }
+  return next;
+}
+function be32(n) {
+  const b = new Uint8Array(4);
+  b[0] = n >>> 24 & 255;
+  b[1] = n >>> 16 & 255;
+  b[2] = n >>> 8 & 255;
+  b[3] = n & 255;
+  return b;
+}
+function fromBase64(b64) {
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function concatBytes(...parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+async function buildHybridTx(opts) {
+  const {
+    registry,
+    signer,
+    pqcKeypair,
+    messages,
+    fee,
+    chainId,
+    accountNumber,
+    sequence
+  } = opts;
+  const memo = opts.memo ?? "";
+  const timeoutHeight = opts.timeoutHeight ?? 0n;
+  const accounts = await signer.getAccounts();
+  if (accounts.length === 0) {
+    throw new Error("signer exposes no accounts");
+  }
+  const account = accounts[0];
+  const encodedMessages = messages.map((m) => registry.encodeAsAny(m));
+  const baseBody = tx$1.TxBody.fromPartial({
+    messages: encodedMessages,
+    memo,
+    timeoutHeight
+  });
+  const b0 = tx$1.TxBody.encode(baseBody).finish();
+  const pubkeyAny = protoSigning.encodePubkey(amino.encodeSecp256k1Pubkey(account.pubkey));
+  const gasLimit = Number(fee.gas);
+  const authInfoBytes = protoSigning.makeAuthInfoBytes(
+    [{ pubkey: pubkeyAny, sequence: BigInt(sequence) }],
+    fee.amount,
+    gasLimit,
+    fee.granter,
+    fee.payer,
+    signing.SignMode.SIGN_MODE_DIRECT
+  );
+  const pqcSignedMessage = concatBytes(
+    be32(b0.length),
+    b0,
+    be32(authInfoBytes.length),
+    authInfoBytes
+  );
+  const pqcSignature = pqcSign(pqcKeypair.secretKey, pqcSignedMessage);
+  const ext = buildHybridSignatureExtension({
+    algorithmId: AlgorithmDilithium5,
+    signature: pqcSignature,
+    publicKey: opts.includePqcPublicKey ? pqcKeypair.publicKey : void 0
+  });
+  const extAny = encodeHybridExtension(ext);
+  const finalBody = tx$1.TxBody.fromPartial({
+    messages: encodedMessages,
+    memo,
+    timeoutHeight,
+    extensionOptions: [extAny]
+  });
+  const bodyBytesFinal = tx$1.TxBody.encode(finalBody).finish();
+  const signDoc = tx$1.SignDoc.fromPartial({
+    bodyBytes: bodyBytesFinal,
+    authInfoBytes,
+    chainId,
+    accountNumber: BigInt(accountNumber)
+  });
+  const { signature } = await signer.signDirect(account.address, signDoc);
+  const classicalSig = fromBase64(signature.signature);
+  const txRaw = tx$1.TxRaw.fromPartial({
+    bodyBytes: bodyBytesFinal,
+    authInfoBytes,
+    signatures: [classicalSig]
+  });
+  const txRawBytes = tx$1.TxRaw.encode(txRaw).finish();
+  return {
+    txRaw,
+    txRawBytes,
+    authInfoBytes,
+    pqcSignedMessage,
+    pqcSignature
+  };
+}
+async function signAndBroadcastHybrid(opts) {
+  const { transport } = opts;
+  const mode = opts.mode ?? "commit";
+  const built = await buildHybridTx(opts);
+  if (mode === "commit") {
+    const res = await transport.broadcastTx(built.txRawBytes);
+    if (res.code !== 0) {
+      throw new Error(
+        `hybrid transaction failed with code ${res.code}: ${res.rawLog ?? "(no log)"} (hash ${res.transactionHash})`
+      );
+    }
+    return {
+      transactionHash: res.transactionHash,
+      code: res.code,
+      height: res.height,
+      gasUsed: res.gasUsed,
+      gasWanted: res.gasWanted,
+      rawLog: res.rawLog
+    };
+  }
+  const hash = await transport.broadcastTxSync(built.txRawBytes);
+  return { transactionHash: hash, code: 0 };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+exports.AlgorithmDilithium5 = AlgorithmDilithium5;
+exports.AlgorithmMLKEM1024 = AlgorithmMLKEM1024;
+exports.AlgorithmUnspecified = AlgorithmUnspecified;
+exports.HYBRID_SIG_TYPE_URL = HYBRID_SIG_TYPE_URL;
+exports.HybridSigner = HybridSigner;
+exports.JsonRpcClient = JsonRpcClient;
+exports.JsonRpcError = JsonRpcError;
+exports.ML_DSA_87_PUBLIC_KEY_LENGTH = ML_DSA_87_PUBLIC_KEY_LENGTH;
+exports.ML_DSA_87_SECRET_KEY_LENGTH = ML_DSA_87_SECRET_KEY_LENGTH;
+exports.ML_DSA_87_SEED_LENGTH = ML_DSA_87_SEED_LENGTH;
+exports.ML_DSA_87_SIGNATURE_LENGTH = ML_DSA_87_SIGNATURE_LENGTH;
+exports.MSG_SEND_TYPE_URL = MSG_SEND_TYPE_URL;
+exports.NETWORKS = NETWORKS;
+exports.PqcSigner = PqcSigner;
+exports.QorClient = QorClient;
+exports.QoreHttpError = QoreHttpError;
+exports.RestClient = RestClient;
+exports.STATIC_FALLBACK = STATIC_FALLBACK;
+exports.TxClient = TxClient;
+exports.VERSION = VERSION;
+exports.algorithmName = algorithmName;
+exports.attachHybridExtension = attachHybridExtension;
+exports.bech32ToHex = bech32ToHex;
+exports.buildHybridSignatureExtension = buildHybridSignatureExtension;
+exports.buildHybridTx = buildHybridTx;
+exports.buildUrl = buildUrl;
+exports.bytesToBech32 = bytesToBech32;
+exports.connectCosmWasmSigner = connectCosmWasmSigner;
+exports.createClient = createClient;
+exports.createCosmWasmClient = createCosmWasmClient;
+exports.deriveEvmAccount = deriveEvmAccount;
+exports.deriveNativeAccount = deriveNativeAccount;
+exports.deriveSvmAccount = deriveSvmAccount;
+exports.directSignerFromPrivateKey = directSignerFromPrivateKey;
+exports.encodeHybridExtension = encodeHybridExtension;
+exports.estimateFee = estimateFee;
+exports.execute = execute;
+exports.fromBase = fromBase;
+exports.generateMnemonic = generateMnemonic;
+exports.generatePqcKeypair = generatePqcKeypair;
+exports.getContractInfo = getContractInfo;
+exports.getCrossVmMessage = getCrossVmMessage;
+exports.getCrossVmParams = getCrossVmParams;
+exports.getJson = getJson;
+exports.getNetwork = getNetwork;
+exports.getPendingCrossVmMessages = getPendingCrossVmMessages;
+exports.hexToBech32 = hexToBech32;
+exports.instantiate = instantiate;
+exports.isSignatureAlgorithm = isSignatureAlgorithm;
+exports.isValidBech32 = isValidBech32;
+exports.joinUrl = joinUrl;
+exports.listNetworks = listNetworks;
+exports.postJsonRpc = postJsonRpc;
+exports.pqcSign = pqcSign;
+exports.pqcVerify = pqcVerify;
+exports.queryContractSmart = queryContractSmart;
+exports.signAndBroadcastHybrid = signAndBroadcastHybrid;
+exports.toBase = toBase;
+exports.uploadCode = uploadCode;
+exports.validateMnemonic = validateMnemonic;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map