@caatinga/client 0.2.1 → 0.2.3

package/README.md

@@ -19,6 +19,16 @@ import { freighterWalletAdapter } from "@caatinga/client/freighter";
 
 The `@caatinga/client/freighter` subpath is optional and only needed when you want the bundled Freighter adapter.
 
+For multi-wallet support, add Stellar Wallets Kit:
+
+```bash
+pnpm add github:Creit-Tech/Stellar-Wallets-Kit#v0.0.7
+```
+
+```ts
+import { createStellarWalletsKitAdapter } from "@caatinga/client/stellar-wallets-kit";
+```
+
 ## What It Solves
 
 `@caatinga/client` is the supported browser and Node integration layer for invoking generated Soroban bindings with Caatinga artifacts, network configuration, and a wallet adapter.
@@ -49,16 +59,21 @@ Supported type-only root exports:
 - `CaatingaInvokeResult`
 - `CaatingaInvokeStatus`
 - `CaatingaNetwork`
+- `CaatingaReadOptions`
+- `CaatingaReadResult`
 - `CaatingaWalletAdapter`
 - `CaatingaXdrBuildResult`
 
 Supported subpath export:
 
 - `@caatinga/client/freighter` -> `freighterWalletAdapter` (optional)
+- `@caatinga/client/stellar-wallets-kit` -> `createStellarWalletsKitAdapter` (optional)
 
 Primary flow:
 
 - `createCaatingaClient(...)`
+- `client.contract(name).read(method, args?)`
+- `client.contract(name).simulate(method, args?)`
 - `client.contract(name).invoke(method, args?)`
 - `client.contract(name).buildXdr(method, args?)`
 
@@ -66,10 +81,12 @@ Primary flow:
 
 ```ts
 import { createCaatingaClient } from "@caatinga/client";
-import { freighterWalletAdapter } from "@caatinga/client/freighter";
+import { createStellarWalletsKitAdapter } from "@caatinga/client/stellar-wallets-kit";
 import * as Counter from "./contracts/generated/counter";
 import artifacts from "../caatinga.artifacts.json";
 
+const wallet = createStellarWalletsKitAdapter();
+
 const client = createCaatingaClient({
   network: {
     name: "testnet",
@@ -77,7 +94,7 @@ const client = createCaatingaClient({
     networkPassphrase: "Test SDF Network ; September 2015"
   },
   artifacts,
-  wallet: freighterWalletAdapter,
+  wallet,
   contracts: {
     counter: {
       binding: Counter
@@ -85,7 +102,9 @@ const client = createCaatingaClient({
   }
 });
 
-const result = await client.contract("counter").invoke("increment");
+const before = await client.contract("counter").read<number>("get");
+const increment = await client.contract("counter").invoke<number>("increment");
+const after = increment.result ?? await client.contract("counter").read<number>("get");
 ```
 
 ## Wallet Adapter Contract

package/dist/freighter.d.cts

@@ -1,5 +1,5 @@
-import { C as CaatingaWalletAdapter } from './types-CiM5FkDn.cjs';
-import '@caatinga/core';
+import { C as CaatingaWalletAdapter } from './types-D4XEyX4J.cjs';
+import '@caatinga/core/browser';
 
 declare const freighterWalletAdapter: CaatingaWalletAdapter;
 

package/dist/freighter.d.ts

@@ -1,5 +1,5 @@
-import { C as CaatingaWalletAdapter } from './types-CiM5FkDn.js';
-import '@caatinga/core';
+import { C as CaatingaWalletAdapter } from './types-D4XEyX4J.js';
+import '@caatinga/core/browser';
 
 declare const freighterWalletAdapter: CaatingaWalletAdapter;
 

package/dist/index.cjs

@@ -29,7 +29,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/artifacts/resolve-contract-id.ts
-var import_core = require("@caatinga/core");
+var import_browser = require("@caatinga/core/browser");
 function resolveContractId(input) {
   if (input.explicitContractId) {
     return input.explicitContractId;
@@ -38,22 +38,22 @@ function resolveContractId(input) {
   if (contractId) {
     return contractId;
   }
-  throw new import_core.CaatingaError(
+  throw new import_browser.CaatingaError(
     `No contract artifact found for "${input.contract}" on "${input.network}".`,
-    import_core.CaatingaErrorCode.CONTRACT_ARTIFACT_NOT_FOUND,
+    import_browser.CaatingaErrorCode.CONTRACT_ARTIFACT_NOT_FOUND,
     "Deploy the contract first or pass contractId explicitly."
   );
 }
 
 // src/bindings/default-binding-adapter.ts
-var import_core2 = require("@caatinga/core");
+var import_browser2 = require("@caatinga/core/browser");
 function createDefaultBindingAdapter(binding) {
   return {
     createClient({ contractId, publicKey, rpcUrl, networkPassphrase }) {
       if (!binding.Client) {
-        throw new import_core2.CaatingaError(
+        throw new import_browser2.CaatingaError(
           "Generated binding does not export Client.",
-          import_core2.CaatingaErrorCode.BINDING_CLIENT_NOT_FOUND,
+          import_browser2.CaatingaErrorCode.BINDING_CLIENT_NOT_FOUND,
           "Regenerate bindings with Stellar CLI."
         );
       }
@@ -68,9 +68,9 @@ function createDefaultBindingAdapter(binding) {
       const candidate = client;
       const fn = candidate[method];
       if (typeof fn !== "function") {
-        throw new import_core2.CaatingaError(
+        throw new import_browser2.CaatingaError(
           `Binding method "${method}" was not found.`,
-          import_core2.CaatingaErrorCode.BINDING_METHOD_NOT_FOUND,
+          import_browser2.CaatingaErrorCode.BINDING_METHOD_NOT_FOUND,
           "Check the contract method name or regenerate bindings."
         );
       }
@@ -80,13 +80,13 @@ function createDefaultBindingAdapter(binding) {
 }
 
 // src/client/create-caatinga-client.ts
-var import_core5 = require("@caatinga/core");
+var import_browser5 = require("@caatinga/core/browser");
 
 // src/client/caatinga-contract-client.ts
-var import_core4 = require("@caatinga/core");
+var import_browser4 = require("@caatinga/core/browser");
 
 // src/xdr/build-xdr.ts
-var import_core3 = require("@caatinga/core");
+var import_browser3 = require("@caatinga/core/browser");
 async function buildXdr(input) {
   try {
     const transaction = input.transaction;
@@ -96,13 +96,13 @@ async function buildXdr(input) {
       try {
         preparedTransaction = await transaction.prepare();
       } catch (error) {
-        if (error instanceof import_core3.CaatingaError) {
+        if (error instanceof import_browser3.CaatingaError) {
           throw error;
         }
-        throw new import_core3.CaatingaError(
+        throw new import_browser3.CaatingaError(
           `Failed to prepare XDR for "${input.contractName}.${input.method}".`,
-          import_core3.CaatingaErrorCode.XDR_PREPARE_FAILED,
-          "Check RPC connectivity, simulation errors, and binding compatibility.",
+          import_browser3.CaatingaErrorCode.XDR_PREPARE_FAILED,
+          `RPC: ${input.rpcUrl}. Check connectivity, simulation errors, and binding compatibility.`,
           error
         );
       }
@@ -119,12 +119,12 @@ async function buildXdr(input) {
       ...input.debug ? { raw: preparedTransaction } : {}
     };
   } catch (error) {
-    if (error instanceof import_core3.CaatingaError) {
+    if (error instanceof import_browser3.CaatingaError) {
       throw error;
     }
-    throw new import_core3.CaatingaError(
+    throw new import_browser3.CaatingaError(
       `Failed to build XDR for "${input.contractName}.${input.method}".`,
-      import_core3.CaatingaErrorCode.XDR_BUILD_FAILED,
+      import_browser3.CaatingaErrorCode.XDR_BUILD_FAILED,
       "Check the generated binding transaction object.",
       error
     );
@@ -133,9 +133,9 @@ async function buildXdr(input) {
 function readXdr(transaction) {
   const candidate = transaction;
   if (typeof candidate.toXDR !== "function") {
-    throw new import_core3.CaatingaError(
+    throw new import_browser3.CaatingaError(
       "Binding transaction object does not expose toXDR().",
-      import_core3.CaatingaErrorCode.XDR_BUILD_FAILED,
+      import_browser3.CaatingaErrorCode.XDR_BUILD_FAILED,
       "Regenerate bindings or provide a compatible binding adapter."
     );
   }
@@ -164,6 +164,7 @@ var CaatingaContractClient = class {
       method,
       contractId,
       transaction,
+      rpcUrl: this.config.network.rpcUrl,
       debug: debugRaw
     });
   }
@@ -175,23 +176,54 @@ var CaatingaContractClient = class {
       method,
       contractId,
       transaction,
+      rpcUrl: this.config.network.rpcUrl,
       debug: debugRaw
     });
     let signedXdr;
-    try {
-      signedXdr = await this.config.wallet.signTransaction({
-        xdr: xdr.preparedXdr,
-        networkPassphrase: this.config.network.networkPassphrase
-      });
-    } catch (error) {
-      throw new import_core4.CaatingaError(
+    const signTransaction = async (xdr2) => {
+      try {
+        signedXdr = await this.withWalletTimeout(
+          "signTransaction",
+          () => this.config.wallet.signTransaction({
+            xdr: xdr2,
+            networkPassphrase: this.config.network.networkPassphrase
+          })
+        );
+      } catch (error) {
+        if (error instanceof import_browser4.CaatingaError) {
+          throw error;
+        }
+        throw new import_browser4.CaatingaError(
+          `Failed to sign XDR for "${this.contractName}.${method}".`,
+          import_browser4.CaatingaErrorCode.XDR_SIGN_FAILED,
+          "Connect a wallet and approve the transaction.",
+          error
+        );
+      }
+      if (typeof signedXdr !== "string" || signedXdr.trim().length === 0) {
+        throw new import_browser4.CaatingaError(
+          `Failed to sign XDR for "${this.contractName}.${method}".`,
+          import_browser4.CaatingaErrorCode.XDR_SIGN_FAILED,
+          "Wallet returned an empty or invalid signed XDR. The user may have dismissed the signing prompt.",
+          signedXdr
+        );
+      }
+      return { signedTxXdr: signedXdr };
+    };
+    const raw = await submitTransaction(
+      transaction,
+      signTransaction,
+      this.contractName,
+      method,
+      this.config.network.rpcUrl
+    );
+    if (typeof transaction.signAndSend === "function" && signedXdr === void 0) {
+      throw new import_browser4.CaatingaError(
         `Failed to sign XDR for "${this.contractName}.${method}".`,
-        import_core4.CaatingaErrorCode.XDR_SIGN_FAILED,
-        "Connect a wallet and approve the transaction.",
-        error
+        import_browser4.CaatingaErrorCode.XDR_SIGN_FAILED,
+        "Wallet returned an empty or invalid signed XDR. The generated transaction did not request a wallet signature."
       );
     }
-    const raw = await submitTransaction(transaction, signedXdr, this.contractName, method);
     const normalized = normalizeSubmitResult(raw);
     return {
       status: "confirmed",
@@ -204,12 +236,35 @@ var CaatingaContractClient = class {
         xdr: {
           unsigned: xdr.unsignedXdr,
           prepared: xdr.preparedXdr,
-          signed: signedXdr
+          ...signedXdr ? { signed: signedXdr } : {}
         }
       } : {},
       ...debugRaw ? { raw } : {}
     };
   }
+  async simulate(method, argsOrOptions, maybeOptions) {
+    const { args, debugRaw } = splitReadArgsAndOptions(argsOrOptions, maybeOptions);
+    const { contractId, transaction } = await this.createTransaction(method, args);
+    const raw = await prepareReadTransaction(
+      transaction,
+      this.contractName,
+      method,
+      this.config.network.rpcUrl
+    );
+    const result = readSimulationResult(raw, this.contractName, method);
+    return {
+      status: "simulated",
+      contract: this.contractName,
+      method,
+      contractId,
+      result,
+      ...debugRaw ? { raw } : {}
+    };
+  }
+  async read(method, argsOrOptions, maybeOptions) {
+    const result = await this.simulate(method, argsOrOptions, maybeOptions);
+    return result.result;
+  }
   async createTransaction(method, args) {
     const contractId = resolveContractId({
       artifacts: this.config.artifacts,
@@ -219,14 +274,17 @@ var CaatingaContractClient = class {
     });
     let publicKey;
     try {
-      publicKey = await this.config.wallet.getPublicKey();
+      publicKey = await this.withWalletTimeout(
+        "getPublicKey",
+        () => this.config.wallet.getPublicKey()
+      );
     } catch (error) {
-      if (error instanceof import_core4.CaatingaError) {
+      if (error instanceof import_browser4.CaatingaError) {
         throw error;
       }
-      throw new import_core4.CaatingaError(
+      throw new import_browser4.CaatingaError(
         `Wallet is not connected or the public key is unavailable for "${this.contractName}".`,
-        import_core4.CaatingaErrorCode.WALLET_NOT_CONNECTED,
+        import_browser4.CaatingaErrorCode.WALLET_NOT_CONNECTED,
         "Connect the wallet and grant account access, then retry.",
         error
       );
@@ -240,6 +298,41 @@ var CaatingaContractClient = class {
     const transaction = await this.bindingAdapter.callMethod({ client, method, args });
     return { contractId, transaction };
   }
+  withWalletTimeout(label, fn) {
+    const timeoutMs = this.config.walletTimeout;
+    if (timeoutMs === void 0 || timeoutMs <= 0) {
+      return fn();
+    }
+    let timedOut = false;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        timedOut = true;
+        reject(
+          new import_browser4.CaatingaError(
+            `Wallet "${label}" timed out after ${timeoutMs}ms.`,
+            import_browser4.CaatingaErrorCode.WALLET_TIMEOUT,
+            "Ensure the wallet adapter rejects on user dismissal, or increase walletTimeout."
+          )
+        );
+      }, timeoutMs);
+      fn().then(
+        (value) => {
+          if (timedOut) {
+            return;
+          }
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          if (timedOut) {
+            return;
+          }
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  }
 };
 function splitArgsAndOptions(argsOrOptions, maybeOptions) {
   return {
@@ -263,52 +356,118 @@ function splitInvokeArgsAndOptions(argsOrOptions, maybeOptions) {
     debugRaw: maybeOptions?.debugRaw ?? false
   };
 }
-async function submitTransaction(transaction, signedXdr, contractName, method) {
+function splitReadArgsAndOptions(argsOrOptions, maybeOptions) {
+  const looksLikeOptions = argsOrOptions !== void 0 && "debugRaw" in argsOrOptions && maybeOptions === void 0;
+  if (looksLikeOptions) {
+    const options = argsOrOptions;
+    return {
+      args: void 0,
+      debugRaw: options.debugRaw ?? false
+    };
+  }
+  return {
+    args: argsOrOptions,
+    debugRaw: maybeOptions?.debugRaw ?? false
+  };
+}
+async function submitTransaction(transaction, signTransaction, contractName, method, rpcUrl) {
   const candidate = transaction;
-  const submit = candidate.signAndSend ?? candidate.send;
-  if (typeof submit !== "function") {
-    throw new import_core4.CaatingaError(
-      `Binding transaction for "${contractName}.${method}" cannot be submitted.`,
-      import_core4.CaatingaErrorCode.XDR_SUBMIT_FAILED,
-      "Regenerate bindings or provide a compatible binding adapter."
-    );
+  if (typeof candidate.signAndSend === "function") {
+    try {
+      const raw = await candidate.signAndSend.call(transaction, { signTransaction });
+      assertSubmitResultRecognized(raw, contractName, method);
+      return raw;
+    } catch (error) {
+      if (error instanceof import_browser4.CaatingaError) {
+        throw error;
+      }
+      throw new import_browser4.CaatingaError(
+        `Failed to submit XDR for "${contractName}.${method}".`,
+        import_browser4.CaatingaErrorCode.XDR_SUBMIT_FAILED,
+        `RPC: ${rpcUrl}. Check wallet signature and RPC connectivity.`,
+        error
+      );
+    }
+  }
+  if (typeof candidate.send === "function") {
+    try {
+      const raw = await candidate.send.call(transaction);
+      assertSubmitResultRecognized(raw, contractName, method);
+      return raw;
+    } catch (error) {
+      if (error instanceof import_browser4.CaatingaError) {
+        throw error;
+      }
+      throw new import_browser4.CaatingaError(
+        `Failed to submit XDR for "${contractName}.${method}".`,
+        import_browser4.CaatingaErrorCode.XDR_SUBMIT_FAILED,
+        `RPC: ${rpcUrl}. Check wallet signature and RPC connectivity.`,
+        error
+      );
+    }
+  }
+  throw new import_browser4.CaatingaError(
+    `Binding transaction for "${contractName}.${method}" cannot be submitted.`,
+    import_browser4.CaatingaErrorCode.XDR_SUBMIT_FAILED,
+    "Regenerate bindings or provide a compatible binding adapter."
+  );
+}
+async function prepareReadTransaction(transaction, contractName, method, rpcUrl) {
+  const candidate = transaction;
+  if (typeof candidate.prepare !== "function") {
+    return transaction;
   }
   try {
-    const raw = await submit.call(transaction, { signedXdr });
-    assertSubmitResultRecognized(raw, contractName, method);
-    return raw;
+    return await candidate.prepare.call(transaction);
   } catch (error) {
-    if (error instanceof import_core4.CaatingaError) {
+    if (error instanceof import_browser4.CaatingaError) {
       throw error;
     }
-    throw new import_core4.CaatingaError(
-      `Failed to submit XDR for "${contractName}.${method}".`,
-      import_core4.CaatingaErrorCode.XDR_SUBMIT_FAILED,
-      "Check wallet signature and RPC connectivity.",
+    throw new import_browser4.CaatingaError(
+      `Failed to prepare XDR for "${contractName}.${method}".`,
+      import_browser4.CaatingaErrorCode.XDR_PREPARE_FAILED,
+      `RPC: ${rpcUrl}. Check connectivity, simulation errors, and binding compatibility.`,
       error
     );
   }
 }
+function readSimulationResult(raw, contractName, method) {
+  if (raw !== null && typeof raw === "object" && "result" in raw) {
+    const result = raw.result;
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  throw new import_browser4.CaatingaError(
+    `Simulation for "${contractName}.${method}" did not return a result.`,
+    import_browser4.CaatingaErrorCode.READ_RESULT_MISSING,
+    `Expected "${contractName}.${method}" to expose a simulation result. Use debugRaw to inspect the generated binding output.`
+  );
+}
 function assertSubmitResultRecognized(raw, contractName, method) {
   if (raw === null || typeof raw !== "object") {
     return;
   }
   const record = raw;
-  const hasTransactionId = "txHash" in record || "transactionHash" in record || "hash" in record;
+  const hasTransactionId = "txHash" in record || "transactionHash" in record || "hash" in record || hasNestedSendTransactionResponseHash(record);
   const hasResult = "result" in record;
   if (hasTransactionId || hasResult) {
     return;
   }
-  throw new import_core4.CaatingaError(
+  throw new import_browser4.CaatingaError(
     `Submit returned an unrecognized payload for "${contractName}.${method}".`,
-    import_core4.CaatingaErrorCode.XDR_RESULT_FAILED,
-    "Expected txHash, transactionHash, hash, or result on the submit response. Use debugRaw to inspect the binding output."
+    import_browser4.CaatingaErrorCode.XDR_RESULT_FAILED,
+    "Expected txHash, transactionHash, hash, sendTransactionResponse.hash, or result on the submit response. Use debugRaw to inspect the binding output."
   );
 }
+function hasNestedSendTransactionResponseHash(record) {
+  const response = record.sendTransactionResponse;
+  return response !== null && typeof response === "object" && "hash" in response;
+}
 function normalizeSubmitResult(raw) {
   const candidate = raw;
   return {
-    transactionHash: candidate.txHash ?? candidate.transactionHash ?? candidate.hash,
+    transactionHash: candidate.txHash ?? candidate.transactionHash ?? candidate.hash ?? candidate.sendTransactionResponse?.hash,
     result: candidate.result
   };
 }
@@ -319,9 +478,9 @@ function createCaatingaClient(config) {
     contract(contractName) {
       const registration = config.contracts[contractName];
       if (!registration) {
-        throw new import_core5.CaatingaError(
+        throw new import_browser5.CaatingaError(
           `Contract "${contractName}" is not registered.`,
-          import_core5.CaatingaErrorCode.CONTRACT_NOT_FOUND,
+          import_browser5.CaatingaErrorCode.CONTRACT_NOT_FOUND,
           "Add the contract binding to createCaatingaClient()."
         );
       }

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import { a as CaatingaBindingAdapter, b as CaatingaClientConfig, c as CaatingaContractRegistration, d as CaatingaXdrBuildResult, e as CaatingaInvokeOptions, f as CaatingaInvokeResult } from './types-CiM5FkDn.cjs';
-export { g as CaatingaInvokeStatus, h as CaatingaNetwork, C as CaatingaWalletAdapter } from './types-CiM5FkDn.cjs';
-import { CaatingaArtifacts } from '@caatinga/core';
+import { a as CaatingaBindingAdapter, b as CaatingaClientConfig, c as CaatingaContractRegistration, d as CaatingaXdrBuildResult, e as CaatingaInvokeOptions, f as CaatingaInvokeResult, g as CaatingaReadOptions, h as CaatingaReadResult } from './types-D4XEyX4J.cjs';
+export { i as CaatingaInvokeStatus, j as CaatingaNetwork, C as CaatingaWalletAdapter } from './types-D4XEyX4J.cjs';
+import { CaatingaArtifacts } from '@caatinga/core/browser';
 
 declare function resolveContractId(input: {
     artifacts: CaatingaArtifacts;
@@ -29,7 +29,10 @@ declare class CaatingaContractClient {
         debugRaw?: boolean;
     }): Promise<CaatingaXdrBuildResult>;
     invoke<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaInvokeOptions, maybeOptions?: CaatingaInvokeOptions): Promise<CaatingaInvokeResult<T>>;
+    simulate<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaReadOptions, maybeOptions?: CaatingaReadOptions): Promise<CaatingaReadResult<T>>;
+    read<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaReadOptions, maybeOptions?: CaatingaReadOptions): Promise<T>;
     private createTransaction;
+    private withWalletTimeout;
 }
 
 declare function createCaatingaClient(config: CaatingaClientConfig): {
@@ -41,7 +44,8 @@ declare function buildXdr(input: {
     method: string;
     contractId: string;
     transaction: unknown;
+    rpcUrl: string;
     debug?: boolean;
 }): Promise<CaatingaXdrBuildResult>;
 
-export { CaatingaBindingAdapter, CaatingaClientConfig, CaatingaContractClient, CaatingaContractRegistration, CaatingaInvokeOptions, CaatingaInvokeResult, CaatingaXdrBuildResult, buildXdr, createCaatingaClient, createDefaultBindingAdapter, resolveContractId };
+export { CaatingaBindingAdapter, CaatingaClientConfig, CaatingaContractClient, CaatingaContractRegistration, CaatingaInvokeOptions, CaatingaInvokeResult, CaatingaReadOptions, CaatingaReadResult, CaatingaXdrBuildResult, buildXdr, createCaatingaClient, createDefaultBindingAdapter, resolveContractId };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { a as CaatingaBindingAdapter, b as CaatingaClientConfig, c as CaatingaContractRegistration, d as CaatingaXdrBuildResult, e as CaatingaInvokeOptions, f as CaatingaInvokeResult } from './types-CiM5FkDn.js';
-export { g as CaatingaInvokeStatus, h as CaatingaNetwork, C as CaatingaWalletAdapter } from './types-CiM5FkDn.js';
-import { CaatingaArtifacts } from '@caatinga/core';
+import { a as CaatingaBindingAdapter, b as CaatingaClientConfig, c as CaatingaContractRegistration, d as CaatingaXdrBuildResult, e as CaatingaInvokeOptions, f as CaatingaInvokeResult, g as CaatingaReadOptions, h as CaatingaReadResult } from './types-D4XEyX4J.js';
+export { i as CaatingaInvokeStatus, j as CaatingaNetwork, C as CaatingaWalletAdapter } from './types-D4XEyX4J.js';
+import { CaatingaArtifacts } from '@caatinga/core/browser';
 
 declare function resolveContractId(input: {
     artifacts: CaatingaArtifacts;
@@ -29,7 +29,10 @@ declare class CaatingaContractClient {
         debugRaw?: boolean;
     }): Promise<CaatingaXdrBuildResult>;
     invoke<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaInvokeOptions, maybeOptions?: CaatingaInvokeOptions): Promise<CaatingaInvokeResult<T>>;
+    simulate<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaReadOptions, maybeOptions?: CaatingaReadOptions): Promise<CaatingaReadResult<T>>;
+    read<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaReadOptions, maybeOptions?: CaatingaReadOptions): Promise<T>;
     private createTransaction;
+    private withWalletTimeout;
 }
 
 declare function createCaatingaClient(config: CaatingaClientConfig): {
@@ -41,7 +44,8 @@ declare function buildXdr(input: {
     method: string;
     contractId: string;
     transaction: unknown;
+    rpcUrl: string;
     debug?: boolean;
 }): Promise<CaatingaXdrBuildResult>;
 
-export { CaatingaBindingAdapter, CaatingaClientConfig, CaatingaContractClient, CaatingaContractRegistration, CaatingaInvokeOptions, CaatingaInvokeResult, CaatingaXdrBuildResult, buildXdr, createCaatingaClient, createDefaultBindingAdapter, resolveContractId };
+export { CaatingaBindingAdapter, CaatingaClientConfig, CaatingaContractClient, CaatingaContractRegistration, CaatingaInvokeOptions, CaatingaInvokeResult, CaatingaReadOptions, CaatingaReadResult, CaatingaXdrBuildResult, buildXdr, createCaatingaClient, createDefaultBindingAdapter, resolveContractId };