@secondlayer/stacks 0.0.1

package/dist/src/index.js

@@ -0,0 +1,629 @@
+import {
+  providerToAccount
+} from "../shared/stacks-qcae5852.js";
+import {
+  defineChain,
+  devnet,
+  mainnet,
+  mocknet,
+  testnet
+} from "../shared/stacks-qt8ehebn.js";
+import {
+  deployContract,
+  getAccountInfo,
+  getBalance,
+  getBlock,
+  getBlockHeight,
+  getContractAbi,
+  multicall,
+  signMessage,
+  signTransactionAction,
+  simulateCall,
+  simulateTransaction,
+  sponsorTransaction,
+  transferStx
+} from "../shared/stacks-n2g56wgg.js";
+import {
+  callContract,
+  estimateFee,
+  getMapEntry,
+  getNonce,
+  readContract,
+  sendTransaction
+} from "../shared/stacks-zm0b3tgy.js";
+import {
+  WebSocketError,
+  watchAddress,
+  watchAddressBalance,
+  watchBlocks,
+  watchMempool,
+  watchNftEvent,
+  watchTransaction
+} from "../shared/stacks-y3dh7hv1.js";
+import"../shared/stacks-709tra19.js";
+import"../shared/stacks-dxhntr76.js";
+import {
+  buildContractCall,
+  buildContractDeploy,
+  buildTokenTransfer
+} from "../shared/stacks-f7wdrzs3.js";
+import {
+  finalizeMultiSig
+} from "../shared/stacks-yfgsm6ap.js";
+import"../shared/stacks-j2cy7qtt.js";
+import"../shared/stacks-8yykgdww.js";
+import {
+  formatStx,
+  parseStx
+} from "../shared/stacks-k2p5tv6x.js";
+import {
+  AddressVersion,
+  MICROSTX_PER_STX,
+  TESTNET_ZERO_ADDRESS,
+  ZERO_ADDRESS
+} from "../shared/stacks-v9jqcpd4.js";
+import"../shared/stacks-bycy6t9k.js";
+import {
+  getContractAddress,
+  isAddressEqual,
+  isValidAddress,
+  parseContractId
+} from "../shared/stacks-gjvbq6w7.js";
+import"../shared/stacks-nqytwfcc.js";
+import {
+  __require
+} from "../shared/stacks-8m9byk2j.js";
+
+// src/clients/createClient.ts
+var BASE_KEYS = new Set(["chain", "account", "transport", "request", "extend"]);
+function createClient(config) {
+  const transport = config.transport({ chain: config.chain });
+  const client = {
+    chain: config.chain,
+    account: config.account,
+    transport,
+    request: transport.request,
+    extend(fn) {
+      const extensions = fn(client);
+      const extended = { ...client };
+      for (const [key, value] of Object.entries(extensions)) {
+        if (BASE_KEYS.has(key))
+          continue;
+        extended[key] = value;
+      }
+      extended.extend = (nextFn) => {
+        const nextExtensions = nextFn(extended);
+        const next = { ...extended };
+        for (const [key, value] of Object.entries(nextExtensions)) {
+          if (BASE_KEYS.has(key))
+            continue;
+          next[key] = value;
+        }
+        next.extend = extended.extend;
+        return next;
+      };
+      return extended;
+    }
+  };
+  return client;
+}
+// src/clients/decorators/public.ts
+function publicActions(client) {
+  return {
+    getNonce: (params) => getNonce(client, params),
+    getBalance: (params) => getBalance(client, params),
+    getAccountInfo: (params) => getAccountInfo(client, params),
+    getBlock: (params) => getBlock(client, params),
+    getBlockHeight: () => getBlockHeight(client),
+    readContract: (params) => readContract(client, params),
+    getContractAbi: (params) => getContractAbi(client, params),
+    getMapEntry: (params) => getMapEntry(client, params),
+    estimateFee: (params) => estimateFee(client, params),
+    multicall: (params) => multicall(client, params),
+    simulateCall: (params) => simulateCall(client, params),
+    simulateTransaction: (params) => simulateTransaction(client, params),
+    watchBlocks: (params) => watchBlocks(client, params),
+    watchMempool: (params) => watchMempool(client, params),
+    watchTransaction: (params) => watchTransaction(client, params),
+    watchAddress: (params) => watchAddress(client, params),
+    watchAddressBalance: (params) => watchAddressBalance(client, params),
+    watchNftEvent: (params) => watchNftEvent(client, params)
+  };
+}
+
+// src/clients/createPublicClient.ts
+function createPublicClient(config) {
+  return createClient(config).extend(publicActions);
+}
+// src/clients/decorators/wallet.ts
+function walletActions(client) {
+  return {
+    sendTransaction: (params) => sendTransaction(client, params),
+    signTransaction: (params) => signTransactionAction(client, params),
+    transferStx: (params) => transferStx(client, params),
+    callContract: (params) => callContract(client, params),
+    deployContract: (params) => deployContract(client, params),
+    signMessage: (params) => signMessage(client, params),
+    sponsorTransaction: (params) => sponsorTransaction(client, params)
+  };
+}
+
+// src/clients/createWalletClient.ts
+function createWalletClient(config) {
+  return createClient(config).extend(walletActions);
+}
+// src/clients/decorators/multisig.ts
+function multisigActions(client) {
+  const msConfig = client._multisigConfig;
+  if (!msConfig)
+    throw new Error("multisigActions requires a multi-sig client");
+  const { signers, requiredSignatures, hashMode } = msConfig;
+  async function resolveNonce(nonce) {
+    if (nonce !== undefined)
+      return nonce;
+    const { makeMultiSigAddress } = await import("../shared/stacks-f3tk2k5s.js");
+    const address = makeMultiSigAddress(signers, requiredSignatures, client.chain);
+    return getNonce(client, { address });
+  }
+  return {
+    async transferStx(params) {
+      const nonce = await resolveNonce(params.nonce);
+      const unsigned = buildTokenTransfer({
+        recipient: params.to,
+        amount: params.amount,
+        memo: params.memo,
+        fee: params.fee ?? 0n,
+        nonce,
+        publicKeys: signers,
+        signaturesRequired: requiredSignatures,
+        hashMode,
+        chain: client.chain,
+        postConditionMode: params.postConditionMode,
+        postConditions: params.postConditions
+      });
+      if (params.fee === undefined) {
+        const estimates = await estimateFee(client, { transaction: unsigned });
+        const mid = estimates[1] ?? estimates[0];
+        if (mid) {
+          unsigned.auth.spendingCondition.fee = BigInt(mid.fee);
+        }
+      }
+      return unsigned;
+    },
+    async callContract(params) {
+      const [contractAddress, contractName] = parseContractId(params.contract);
+      const nonce = await resolveNonce(params.nonce);
+      const unsigned = buildContractCall({
+        contractAddress,
+        contractName,
+        functionName: params.functionName,
+        functionArgs: params.functionArgs ?? [],
+        fee: params.fee ?? 0n,
+        nonce,
+        publicKeys: signers,
+        signaturesRequired: requiredSignatures,
+        hashMode,
+        chain: client.chain,
+        postConditionMode: params.postConditionMode,
+        postConditions: params.postConditions
+      });
+      if (params.fee === undefined) {
+        const estimates = await estimateFee(client, { transaction: unsigned });
+        const mid = estimates[1] ?? estimates[0];
+        if (mid) {
+          unsigned.auth.spendingCondition.fee = BigInt(mid.fee);
+        }
+      }
+      return unsigned;
+    },
+    async deployContract(params) {
+      const nonce = await resolveNonce(params.nonce);
+      const unsigned = buildContractDeploy({
+        contractName: params.contractName,
+        codeBody: params.codeBody,
+        clarityVersion: params.clarityVersion,
+        fee: params.fee ?? 0n,
+        nonce,
+        publicKeys: signers,
+        signaturesRequired: requiredSignatures,
+        hashMode,
+        chain: client.chain,
+        postConditionMode: params.postConditionMode,
+        postConditions: params.postConditions
+      });
+      if (params.fee === undefined) {
+        const estimates = await estimateFee(client, { transaction: unsigned });
+        const mid = estimates[1] ?? estimates[0];
+        if (mid) {
+          unsigned.auth.spendingCondition.fee = BigInt(mid.fee);
+        }
+      }
+      return unsigned;
+    },
+    async sendTransaction(params) {
+      const finalized = finalizeMultiSig(params.transaction, signers);
+      return sendTransaction(client, {
+        transaction: finalized,
+        attachment: params.attachment
+      });
+    }
+  };
+}
+
+// src/clients/createMultiSigClient.ts
+function createMultiSigClient(config) {
+  const client = createClient(config);
+  client._multisigConfig = {
+    signers: config.signers,
+    requiredSignatures: config.requiredSignatures,
+    hashMode: config.hashMode
+  };
+  return client.extend(multisigActions);
+}
+// src/transports/createTransport.ts
+function createTransport(type, config) {
+  return {
+    type,
+    request: config.request,
+    config
+  };
+}
+async function fetchWithRetry(url, options, retryCount, retryDelay, timeout) {
+  let lastError;
+  for (let attempt = 0;attempt <= retryCount; attempt++) {
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok || response.status < 500) {
+        return response;
+      }
+      lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+    }
+    if (attempt < retryCount) {
+      await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
+    }
+  }
+  throw lastError ?? new Error("Request failed");
+}
+function buildRequestFn(baseUrl, config) {
+  const {
+    timeout = 30000,
+    retryCount = 3,
+    retryDelay = 150,
+    fetchOptions = {},
+    apiKey
+  } = config;
+  return async (path, options) => {
+    const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...fetchOptions.headers,
+      ...options?.headers
+    };
+    if (apiKey) {
+      headers["x-api-key"] = apiKey;
+    }
+    const init = {
+      ...fetchOptions,
+      method: options?.method ?? "GET",
+      headers
+    };
+    if (options?.body !== undefined) {
+      init.body = JSON.stringify(options.body);
+    }
+    const response = await fetchWithRetry(url, init, retryCount, retryDelay, timeout);
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return response.json();
+    }
+    return response.text();
+  };
+}
+
+// src/transports/http.ts
+function http(url, config) {
+  return (params) => {
+    const resolvedUrl = url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
+    const mergedConfig = {
+      ...config,
+      url: resolvedUrl
+    };
+    return createTransport("http", {
+      ...mergedConfig,
+      request: buildRequestFn(resolvedUrl, mergedConfig)
+    });
+  };
+}
+// src/transports/custom.ts
+function custom(params) {
+  return () => createTransport("custom", { request: params.request });
+}
+// src/transports/fallback.ts
+function fallback(transports) {
+  return (params) => {
+    const resolved = transports.map((t) => t(params));
+    return createTransport("fallback", {
+      request: async (path, options) => {
+        let lastError;
+        for (const transport of resolved) {
+          try {
+            return await transport.request(path, options);
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+          }
+        }
+        throw lastError ?? new Error("All transports failed");
+      }
+    });
+  };
+}
+// src/transports/webSocket.ts
+function subKey(params) {
+  const parts = [params.event];
+  if (params.tx_id)
+    parts.push(`tx_id:${params.tx_id}`);
+  if (params.address)
+    parts.push(`address:${params.address}`);
+  if (params.asset_identifier)
+    parts.push(`asset:${params.asset_identifier}`);
+  if (params.value)
+    parts.push(`value:${params.value}`);
+  return parts.join("|");
+}
+
+class WebSocketChannel {
+  ws = null;
+  url;
+  nextId = 1;
+  pending = new Map;
+  subs = new Map;
+  destroyed = false;
+  reconnecting = false;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  reconnect;
+  reconnectMaxAttempts;
+  reconnectBaseDelay;
+  constructor(url, config) {
+    this.url = url;
+    this.reconnect = config?.reconnect ?? true;
+    this.reconnectMaxAttempts = config?.reconnectMaxAttempts ?? 10;
+    this.reconnectBaseDelay = config?.reconnectBaseDelay ?? 1000;
+  }
+  connect() {
+    if (this.ws?.readyState === WebSocket.OPEN)
+      return Promise.resolve();
+    if (this.ws?.readyState === WebSocket.CONNECTING) {
+      return new Promise((resolve, reject) => {
+        const onOpen = () => {
+          this.ws?.removeEventListener("error", onError);
+          resolve();
+        };
+        const onError = (e) => {
+          this.ws?.removeEventListener("open", onOpen);
+          reject(new WebSocketError("WebSocket connection failed", {
+            details: String(e)
+          }));
+        };
+        this.ws.addEventListener("open", onOpen, { once: true });
+        this.ws.addEventListener("error", onError, { once: true });
+      });
+    }
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.url);
+      this.ws.addEventListener("open", () => {
+        this.reconnectAttempt = 0;
+        this.reconnecting = false;
+        resolve();
+      }, { once: true });
+      this.ws.addEventListener("error", (e) => {
+        reject(new WebSocketError("WebSocket connection failed", {
+          details: String(e)
+        }));
+      }, { once: true });
+      this.ws.addEventListener("message", (event) => {
+        this.handleMessage(event.data);
+      });
+      this.ws.addEventListener("close", () => {
+        if (!this.destroyed)
+          this.handleDisconnect();
+      });
+    });
+  }
+  handleMessage(raw) {
+    const data = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if ("id" in msg && msg.id != null) {
+      const rpc = msg;
+      const p = this.pending.get(rpc.id);
+      if (!p)
+        return;
+      this.pending.delete(rpc.id);
+      if (rpc.error) {
+        p.reject(new WebSocketError(rpc.error.message, {
+          details: `JSON-RPC error ${rpc.error.code}`
+        }));
+      } else {
+        p.resolve(rpc.result);
+      }
+      return;
+    }
+    const notif = msg;
+    if (!notif.method)
+      return;
+    for (const [, entry] of this.subs) {
+      if (entry.params.event === notif.method) {
+        for (const cb of entry.callbacks) {
+          try {
+            cb(notif.params);
+          } catch {}
+        }
+      }
+    }
+  }
+  handleDisconnect() {
+    this.ws = null;
+    for (const [, p] of this.pending) {
+      p.reject(new WebSocketError("WebSocket disconnected"));
+    }
+    this.pending.clear();
+    if (this.reconnect && this.subs.size > 0 && this.reconnectAttempt < this.reconnectMaxAttempts) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.destroyed || this.reconnecting)
+      return;
+    this.reconnecting = true;
+    const delay = this.reconnectBaseDelay * 2 ** this.reconnectAttempt;
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnecting = false;
+      try {
+        await this.connect();
+        await this.resubscribeAll();
+      } catch {
+        if (!this.destroyed && this.subs.size > 0) {
+          this.handleDisconnect();
+        }
+      }
+    }, delay);
+  }
+  async resubscribeAll() {
+    for (const [, entry] of this.subs) {
+      await this.sendRpc("subscribe", entry.params);
+    }
+  }
+  sendRpc(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        return reject(new WebSocketError("WebSocket not connected"));
+      }
+      const id = this.nextId++;
+      const msg = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      };
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify(msg));
+    });
+  }
+  async subscribe(params, callback) {
+    if (this.destroyed) {
+      throw new WebSocketError("WebSocket channel has been destroyed");
+    }
+    await this.connect();
+    const key = subKey(params);
+    let entry = this.subs.get(key);
+    if (entry) {
+      entry.callbacks.add(callback);
+    } else {
+      entry = { params, callbacks: new Set([callback]) };
+      this.subs.set(key, entry);
+      await this.sendRpc("subscribe", params);
+    }
+    return {
+      unsubscribe: () => {
+        const e = this.subs.get(key);
+        if (!e)
+          return;
+        e.callbacks.delete(callback);
+        if (e.callbacks.size === 0) {
+          this.subs.delete(key);
+          if (this.ws?.readyState === WebSocket.OPEN) {
+            this.sendRpc("unsubscribe", params).catch(() => {});
+          }
+          if (this.subs.size === 0)
+            this.closeQuietly();
+        }
+      }
+    };
+  }
+  closeQuietly() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
+    for (const [, p] of this.pending) {
+      p.reject(new WebSocketError("WebSocket channel destroyed"));
+    }
+    this.pending.clear();
+    this.subs.clear();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+}
+function deriveWsUrl(httpUrl) {
+  return httpUrl.replace(/^http/, "ws").replace(/\/$/, "") + "/extended/v1/ws";
+}
+function webSocket(url, config) {
+  return (params) => {
+    const httpUrl = config?.url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
+    const wsUrl = url ?? params?.chain?.rpcUrls.default.ws?.[0] ?? deriveWsUrl(httpUrl);
+    const resolvedHttpConfig = {
+      ...config,
+      url: httpUrl
+    };
+    const channel = new WebSocketChannel(wsUrl, config);
+    const transport = {
+      type: "webSocket",
+      request: buildRequestFn(httpUrl, resolvedHttpConfig),
+      config: resolvedHttpConfig,
+      subscribe: (subParams, callback) => channel.subscribe(subParams, callback),
+      destroy: () => channel.destroy()
+    };
+    return transport;
+  };
+}
+export {
+  webSocket,
+  walletActions,
+  testnet,
+  publicActions,
+  providerToAccount,
+  parseStx,
+  multisigActions,
+  mocknet,
+  mainnet,
+  isValidAddress,
+  isAddressEqual,
+  http,
+  getContractAddress,
+  formatStx,
+  fallback,
+  devnet,
+  defineChain,
+  custom,
+  createWalletClient,
+  createPublicClient,
+  createMultiSigClient,
+  createClient,
+  ZERO_ADDRESS,
+  TESTNET_ZERO_ADDRESS,
+  MICROSTX_PER_STX,
+  AddressVersion
+};
+
+//# debugId=BE2F1CEE4CB45C8564756E2164756E21
+//# sourceMappingURL=index.js.map