@tangle-network/tcloud 0.1.0

package/dist/shielded.cjs

@@ -0,0 +1,608 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/shielded.ts
+var shielded_exports = {};
+__export(shielded_exports, {
+  createShieldedClient: () => createShieldedClient,
+  estimateCost: () => estimateCost,
+  generateWallet: () => generateWallet,
+  signSpendAuth: () => signSpendAuth
+});
+module.exports = __toCommonJS(shielded_exports);
+var import_accounts = require("viem/accounts");
+var import_viem = require("viem");
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.tangleai.cloud/v1";
+async function proxiedFetch(privacy, url, init, streaming) {
+  if (!privacy || privacy.mode === "direct") {
+    return fetch(url, init);
+  }
+  if (privacy.mode === "relayer") {
+    if (!privacy.relayerUrl) {
+      throw new Error('relayerUrl is required when privacy mode is "relayer"');
+    }
+    const proxyPath = streaming ? "/relay/proxy-stream" : "/relay/proxy";
+    const hdrs = {};
+    if (init.headers) {
+      const entries = init.headers instanceof Headers ? Array.from(init.headers.entries()) : Object.entries(init.headers);
+      for (const [k, v] of entries) hdrs[k] = v;
+    }
+    return fetch(`${privacy.relayerUrl}${proxyPath}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        target: url,
+        body: typeof init.body === "string" ? JSON.parse(init.body) : init.body,
+        headers: hdrs
+      })
+    });
+  }
+  if (privacy.mode === "socks5") {
+    if (!privacy.socksProxy) {
+      throw new Error('socksProxy is required when privacy mode is "socks5"');
+    }
+    const { SocksProxyAgent } = await import("socks-proxy-agent");
+    const agent = new SocksProxyAgent(privacy.socksProxy);
+    return fetch(url, {
+      ...init,
+      // @ts-expect-error agent is supported by Node's undici but not in the standard RequestInit type
+      agent
+    });
+  }
+  return fetch(url, init);
+}
+var TCloudClient = class {
+  baseURL;
+  apiKey;
+  model;
+  headers;
+  spendAuthFn;
+  privacy;
+  limits;
+  _totalSpent = 0;
+  _requestCount = 0;
+  constructor(config = {}) {
+    this.baseURL = (config.baseURL || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.apiKey = config.apiKey || process.env.TCLOUD_API_KEY || process.env.OPENAI_API_KEY;
+    this.model = config.model || "gpt-4o-mini";
+    this.privacy = config.privacy;
+    this.limits = config.limits;
+    this.headers = {
+      "Content-Type": "application/json",
+      "X-Tangle-Client": "tcloud-sdk/0.1.0"
+    };
+    if (this.apiKey) {
+      this.headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    if (config.routing?.prefer) {
+      this.headers["X-Tangle-Operator"] = config.routing.prefer;
+    }
+    if (config.routing?.region) {
+      this.headers["X-Tangle-Region"] = config.routing.region;
+    }
+  }
+  /** Set the SpendAuth signer for private mode */
+  setSpendAuthSigner(fn) {
+    this.spendAuthFn = fn;
+  }
+  /** Current metering stats */
+  get usage() {
+    return {
+      totalSpent: this._totalSpent,
+      requestCount: this._requestCount,
+      limits: this.limits ? { ...this.limits } : void 0
+    };
+  }
+  /** Check spending limits before a request. Throws TCloudError if blocked. */
+  checkLimits() {
+    if (!this.limits) return;
+    if (this.limits.maxRequests && this._requestCount >= this.limits.maxRequests) {
+      this.limits.onLimitReached?.({ type: "requests", current: this._requestCount, limit: this.limits.maxRequests });
+      throw new TCloudError(429, `Request limit reached (${this._requestCount}/${this.limits.maxRequests})`);
+    }
+    if (this.limits.maxTotalSpend && this._totalSpent >= this.limits.maxTotalSpend) {
+      this.limits.onLimitReached?.({ type: "total", current: this._totalSpent, limit: this.limits.maxTotalSpend });
+      throw new TCloudError(429, `Spending limit reached ($${this._totalSpent.toFixed(6)}/$${this.limits.maxTotalSpend})`);
+    }
+    if (this.limits.maxRequests && this.limits.onLimitWarning) {
+      const pct = this._requestCount / this.limits.maxRequests;
+      if (pct >= 0.8) this.limits.onLimitWarning({ type: "requests", current: this._requestCount, limit: this.limits.maxRequests });
+    }
+    if (this.limits.maxTotalSpend && this.limits.onLimitWarning) {
+      const pct = this._totalSpent / this.limits.maxTotalSpend;
+      if (pct >= 0.8) this.limits.onLimitWarning({ type: "total", current: this._totalSpent, limit: this.limits.maxTotalSpend });
+    }
+  }
+  /** Track cost after a response */
+  trackCost(completion) {
+    this._requestCount++;
+    if (completion.usage) {
+      const tokens = completion.usage.total_tokens || 0;
+      const estimatedCost = tokens * 1e-6;
+      this._totalSpent += estimatedCost;
+      if (this.limits?.maxCostPerRequest && estimatedCost > this.limits.maxCostPerRequest) {
+        this.limits.onLimitReached?.({ type: "cost", current: estimatedCost, limit: this.limits.maxCostPerRequest });
+      }
+    }
+  }
+  /** Chat completion (non-streaming) */
+  async chat(options) {
+    this.checkLimits();
+    const headers = { ...this.headers };
+    if (this.spendAuthFn) {
+      const auth = await this.spendAuthFn();
+      headers["X-Payment-Signature"] = JSON.stringify(auth);
+      delete headers["Authorization"];
+    }
+    const res = await proxiedFetch(this.privacy, `${this.baseURL}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: options.model || this.model,
+        messages: options.messages,
+        temperature: options.temperature,
+        max_tokens: options.maxTokens,
+        stream: false,
+        stop: options.stop,
+        top_p: options.topP,
+        frequency_penalty: options.frequencyPenalty,
+        presence_penalty: options.presencePenalty,
+        response_format: options.responseFormat,
+        tools: options.tools
+      })
+    }, false);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new TCloudError(res.status, err.error?.message || err.error || err.message || res.statusText);
+    }
+    const completion = await res.json();
+    this.trackCost(completion);
+    return completion;
+  }
+  /** Chat completion (streaming) — returns an async iterator of chunks */
+  async *chatStream(options) {
+    this.checkLimits();
+    const headers = { ...this.headers };
+    if (this.spendAuthFn) {
+      const auth = await this.spendAuthFn();
+      headers["X-Payment-Signature"] = JSON.stringify(auth);
+      delete headers["Authorization"];
+    }
+    const res = await proxiedFetch(this.privacy, `${this.baseURL}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: options.model || this.model,
+        messages: options.messages,
+        temperature: options.temperature,
+        max_tokens: options.maxTokens,
+        stream: true,
+        stop: options.stop,
+        top_p: options.topP
+      })
+    }, true);
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: res.statusText }));
+      throw new TCloudError(res.status, err.error || err.message || res.statusText);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") {
+          this._requestCount++;
+          return;
+        }
+        try {
+          yield JSON.parse(data);
+        } catch {
+        }
+      }
+    }
+  }
+  /** Convenience: send a single message and get the text response */
+  async ask(message, modelOrOptions) {
+    const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
+    const completion = await this.chat({
+      messages: [{ role: "user", content: message }],
+      ...options
+    });
+    return completion.choices[0]?.message?.content || "";
+  }
+  /** Convenience: send a single message and get the full completion (with usage) */
+  async askFull(message, modelOrOptions) {
+    const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
+    return this.chat({
+      messages: [{ role: "user", content: message }],
+      ...options
+    });
+  }
+  /** Convenience: stream a single message and yield text chunks */
+  async *askStream(message, modelOrOptions) {
+    const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
+    for await (const chunk of this.chatStream({
+      messages: [{ role: "user", content: message }],
+      ...options
+    })) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) yield content;
+    }
+  }
+  /** List available models */
+  async models() {
+    const res = await proxiedFetch(this.privacy, `${this.baseURL}/models`, { headers: this.headers }, false);
+    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch models");
+    const data = await res.json();
+    return data.data || [];
+  }
+  /** List active operators */
+  async operators() {
+    const apiRoot = this.baseURL.replace(/\/v1$/, "");
+    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/operators`, { headers: this.headers }, false);
+    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch operators");
+    return res.json();
+  }
+  /** Get credit balance */
+  async credits() {
+    const apiRoot = this.baseURL.replace(/\/v1$/, "");
+    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/billing`, { headers: this.headers }, false);
+    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch credits");
+    return res.json();
+  }
+  /** Add credits */
+  async addCredits(amount) {
+    const apiRoot = this.baseURL.replace(/\/v1$/, "");
+    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/billing`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ amount })
+    }, false);
+    if (!res.ok) throw new TCloudError(res.status, "Failed to add credits");
+    return res.json();
+  }
+  /** Create a new API key */
+  async createKey(name) {
+    const apiRoot = this.baseURL.replace(/\/v1$/, "");
+    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/keys`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ name })
+    }, false);
+    if (!res.ok) throw new TCloudError(res.status, "Failed to create API key");
+    return res.json();
+  }
+  /** List API keys */
+  async keys() {
+    const apiRoot = this.baseURL.replace(/\/v1$/, "");
+    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/keys`, { headers: this.headers }, false);
+    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch keys");
+    return res.json();
+  }
+  /** Revoke an API key */
+  async revokeKey(id) {
+    const apiRoot = this.baseURL.replace(/\/v1$/, "");
+    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/keys/${id}`, {
+      method: "DELETE",
+      headers: this.headers
+    }, false);
+    if (!res.ok) throw new TCloudError(res.status, "Failed to revoke key");
+  }
+  /** Search models by name, provider, or capability */
+  async searchModels(query) {
+    const all = await this.models();
+    const q = query.toLowerCase();
+    return all.filter(
+      (m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q) || m._provider && m._provider.toLowerCase().includes(q)
+    );
+  }
+  /** Estimate cost for a request (without sending it) */
+  async estimateCost(options) {
+    const models = await this.models();
+    const model = models.find((m) => m.id === (options.model || this.model));
+    if (!model) return { inputCost: 0, outputCost: 0, total: 0 };
+    const inputCost = options.inputTokens * parseFloat(model.pricing.prompt);
+    const outputCost = options.outputTokens * parseFloat(model.pricing.completion);
+    return { inputCost, outputCost, total: inputCost + outputCost };
+  }
+};
+var TCloudError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "TCloudError";
+  }
+};
+
+// src/shielded.ts
+var SPEND_TYPEHASH = (0, import_viem.keccak256)(
+  (0, import_viem.toBytes)(
+    "SpendAuthorization(bytes32 commitment,uint64 serviceId,uint8 jobIndex,uint256 amount,address operator,uint256 nonce,uint64 expiry)"
+  )
+);
+var DEFAULT_DOMAIN = {
+  name: "ShieldedCredits",
+  version: "1"
+};
+function generateWallet() {
+  const privateKeyBytes = crypto.getRandomValues(new Uint8Array(32));
+  const privateKey = "0x" + Array.from(privateKeyBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const saltBytes = crypto.getRandomValues(new Uint8Array(32));
+  const salt = "0x" + Array.from(saltBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+  const commitment = (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)(
+      (0, import_viem.parseAbiParameters)("address, bytes32"),
+      [account.address, salt]
+    )
+  );
+  return { privateKey, address: account.address, commitment, salt };
+}
+async function signSpendAuth(wallet, params) {
+  const account = (0, import_accounts.privateKeyToAccount)(wallet.privateKey);
+  const domainSeparator = (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)(
+      (0, import_viem.parseAbiParameters)("bytes32, bytes32, bytes32, uint256, address"),
+      [
+        (0, import_viem.keccak256)((0, import_viem.toBytes)("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")),
+        (0, import_viem.keccak256)((0, import_viem.toBytes)(DEFAULT_DOMAIN.name)),
+        (0, import_viem.keccak256)((0, import_viem.toBytes)(DEFAULT_DOMAIN.version)),
+        BigInt(params.chainId),
+        params.creditsAddress
+      ]
+    )
+  );
+  const structHash = (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)(
+      (0, import_viem.parseAbiParameters)("bytes32, bytes32, uint64, uint8, uint256, address, uint256, uint64"),
+      [
+        SPEND_TYPEHASH,
+        wallet.commitment,
+        params.serviceId,
+        params.jobIndex,
+        params.amount,
+        params.operator,
+        params.nonce,
+        params.expiry
+      ]
+    )
+  );
+  const digest = (0, import_viem.keccak256)(
+    (0, import_viem.concat)([(0, import_viem.toBytes)("0x1901"), (0, import_viem.toBytes)(domainSeparator), (0, import_viem.toBytes)(structHash)])
+  );
+  const signature = await account.sign({ hash: digest });
+  return {
+    commitment: wallet.commitment,
+    serviceId: params.serviceId.toString(),
+    jobIndex: params.jobIndex,
+    amount: params.amount.toString(),
+    operator: params.operator,
+    nonce: params.nonce.toString(),
+    expiry: params.expiry.toString(),
+    signature
+  };
+}
+function estimateCost(inputTokens, maxOutputTokens, inputPricePerM = 0.15, outputPricePerM = 0.6) {
+  const cost = inputTokens / 1e6 * inputPricePerM + maxOutputTokens / 1e6 * outputPricePerM;
+  return BigInt(Math.ceil(cost * 1e6));
+}
+function createShieldedClient(config = {}) {
+  const wallet = config.wallet || generateWallet();
+  const chainId = config.chainId || 3799;
+  const creditsAddress = config.creditsAddress || "0x0000000000000000000000000000000000000000";
+  const operatorAddress = config.operatorAddress || "0x0000000000000000000000000000000000000000";
+  const serviceId = config.serviceId || 1n;
+  let nonce = 0n;
+  const client = new TCloudClient({
+    ...config,
+    apiKey: void 0
+    // no API key in private mode
+  });
+  client.setSpendAuthSigner(async () => {
+    const currentNonce = nonce++;
+    const amount = estimateCost(500, 4096);
+    const buffered = amount + amount / 5n;
+    return signSpendAuth(wallet, {
+      serviceId,
+      jobIndex: 0,
+      amount: buffered,
+      operator: operatorAddress,
+      nonce: currentNonce,
+      expiry: BigInt(Math.floor(Date.now() / 1e3) + 300),
+      chainId,
+      creditsAddress
+    });
+  });
+  const monitor = { lastBalance: 0n, timer: null, replenishing: false };
+  if (config.autoReplenish) {
+    const ar = config.autoReplenish;
+    const intervalMs = ar.checkIntervalMs ?? 3e4;
+    const check = async () => {
+      try {
+        const balance = await fetchBalance(wallet.commitment, creditsAddress, chainId);
+        monitor.lastBalance = balance;
+        if (balance < ar.minBalance && !monitor.replenishing) {
+          monitor.replenishing = true;
+          try {
+            if (ar.fundingSource === "relayer") {
+              await replenishViaRelayer(ar.relayerUrl, wallet.commitment, wallet.privateKey);
+            } else {
+              await replenishDirect(
+                ar.fundingWalletKey,
+                ar.tokenAddress,
+                ar.replenishAmount,
+                wallet.commitment,
+                wallet.address,
+                creditsAddress,
+                chainId
+              );
+            }
+            monitor.lastBalance = await fetchBalance(wallet.commitment, creditsAddress, chainId);
+            console.log(`[tcloud/shielded] replenished. balance=${monitor.lastBalance}`);
+          } finally {
+            monitor.replenishing = false;
+          }
+        }
+      } catch (err) {
+        console.error("[tcloud/shielded] auto-replenish error:", err instanceof Error ? err.message : String(err));
+      }
+    };
+    void check();
+    monitor.timer = setInterval(() => void check(), intervalMs);
+  }
+  function stopAutoReplenish() {
+    if (monitor.timer) {
+      clearInterval(monitor.timer);
+      monitor.timer = null;
+    }
+  }
+  return Object.assign(client, { wallet, stopAutoReplenish });
+}
+var GET_ACCOUNT_ABI = [{
+  type: "function",
+  name: "getAccount",
+  inputs: [{ name: "commitment", type: "bytes32" }],
+  outputs: [{
+    name: "",
+    type: "tuple",
+    components: [
+      { name: "spendingKey", type: "address" },
+      { name: "token", type: "address" },
+      { name: "balance", type: "uint256" },
+      { name: "totalFunded", type: "uint256" },
+      { name: "totalSpent", type: "uint256" },
+      { name: "nonce", type: "uint256" }
+    ]
+  }],
+  stateMutability: "view"
+}];
+var FUND_CREDITS_ABI = [{
+  type: "function",
+  name: "fundCredits",
+  inputs: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "commitment", type: "bytes32" },
+    { name: "spendingKey", type: "address" }
+  ],
+  outputs: [],
+  stateMutability: "nonpayable"
+}];
+var ERC20_APPROVE_ABI = [{
+  type: "function",
+  name: "approve",
+  inputs: [
+    { name: "spender", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  outputs: [{ name: "", type: "bool" }],
+  stateMutability: "nonpayable"
+}];
+function makeChain(chainId, rpcUrl) {
+  return {
+    id: chainId,
+    name: `chain-${chainId}`,
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  };
+}
+function getRpcUrl(chainId) {
+  if (chainId === 3799) return "https://testnet-rpc.tangle.tools";
+  if (chainId === 5845) return "https://rpc.tangle.tools";
+  return "http://localhost:8545";
+}
+async function fetchBalance(commitment, creditsAddress, chainId) {
+  const { createPublicClient, http } = await import("viem");
+  const rpcUrl = getRpcUrl(chainId);
+  const client = createPublicClient({ chain: makeChain(chainId, rpcUrl), transport: http(rpcUrl) });
+  const result = await client.readContract({
+    address: creditsAddress,
+    abi: GET_ACCOUNT_ABI,
+    functionName: "getAccount",
+    args: [commitment]
+  });
+  return result.balance;
+}
+async function replenishViaRelayer(relayerUrl, commitment, spendingKey) {
+  const res = await fetch(`${relayerUrl.replace(/\/$/, "")}/relay/fund-credits`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      anchorProof: { proof: "0x", auxPublicInputs: "0x", externalData: "0x", publicInputs: "0x", encryptions: "0x" },
+      commitment,
+      spendingKey
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`relayer fund-credits failed (${res.status}): ${body}`);
+  }
+}
+async function replenishDirect(fundingKey, tokenAddress, amount, commitment, spendingKeyAddress, creditsAddress, chainId) {
+  const { createPublicClient, createWalletClient, http } = await import("viem");
+  const { privateKeyToAccount: toAccount } = await import("viem/accounts");
+  const rpcUrl = getRpcUrl(chainId);
+  const chain = makeChain(chainId, rpcUrl);
+  const account = toAccount(fundingKey);
+  const pub = createPublicClient({ chain, transport: http(rpcUrl) });
+  const wal = createWalletClient({ account, chain, transport: http(rpcUrl) });
+  const approveHash = await wal.writeContract({
+    address: tokenAddress,
+    abi: ERC20_APPROVE_ABI,
+    functionName: "approve",
+    args: [creditsAddress, amount]
+  });
+  await pub.waitForTransactionReceipt({ hash: approveHash });
+  const fundHash = await wal.writeContract({
+    address: creditsAddress,
+    abi: FUND_CREDITS_ABI,
+    functionName: "fundCredits",
+    args: [tokenAddress, amount, commitment, spendingKeyAddress]
+  });
+  const receipt = await pub.waitForTransactionReceipt({ hash: fundHash });
+  if (receipt.status !== "success") {
+    throw new Error(`fundCredits reverted (tx: ${fundHash})`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createShieldedClient,
+  estimateCost,
+  generateWallet,
+  signSpendAuth
+});

package/dist/shielded.d.cts

@@ -0,0 +1,2 @@
+import 'viem';
+export { A as AutoReplenishOptions, S as ShieldedWallet, h as SpendAuth, k as createShieldedClient, l as estimateCost, g as generateWallet, s as signSpendAuth } from './shielded-BRhsV-s-.cjs';

package/dist/shielded.d.ts

@@ -0,0 +1,2 @@
+import 'viem';
+export { A as AutoReplenishOptions, S as ShieldedWallet, h as SpendAuth, k as createShieldedClient, l as estimateCost, g as generateWallet, s as signSpendAuth } from './shielded-BRhsV-s-.js';

package/dist/shielded.js

@@ -0,0 +1,12 @@
+import {
+  createShieldedClient,
+  estimateCost,
+  generateWallet,
+  signSpendAuth
+} from "./chunk-4AOQNUQ3.js";
+export {
+  createShieldedClient,
+  estimateCost,
+  generateWallet,
+  signSpendAuth
+};