@caatinga/client 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Kaleido contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,136 @@
+# @caatinga/client
+
+## Install
+
+```bash
+pnpm add @caatinga/client
+```
+
+If you are using Freighter, add the optional adapter dependency:
+
+```bash
+pnpm add @stellar/freighter-api
+```
+
+```ts
+import { createCaatingaClient } from "@caatinga/client";
+import { freighterWalletAdapter } from "@caatinga/client/freighter";
+```
+
+The `@caatinga/client/freighter` subpath is optional and only needed when you want the bundled Freighter adapter.
+
+## 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.
+
+It connects:
+
+- generated contract bindings
+- `caatinga.artifacts.json`
+- RPC URL and network passphrase
+- wallet-backed signing for invocation and XDR preparation flows
+
+## Supported Surface
+
+Supported runtime root exports:
+
+- `createCaatingaClient`
+- `resolveContractId`
+- `createDefaultBindingAdapter`
+- `CaatingaContractClient`
+- `buildXdr`
+
+Supported type-only root exports:
+
+- `CaatingaBindingAdapter`
+- `CaatingaClientConfig`
+- `CaatingaContractRegistration`
+- `CaatingaInvokeOptions`
+- `CaatingaInvokeResult`
+- `CaatingaInvokeStatus`
+- `CaatingaNetwork`
+- `CaatingaWalletAdapter`
+- `CaatingaXdrBuildResult`
+
+Supported subpath export:
+
+- `@caatinga/client/freighter` -> `freighterWalletAdapter` (optional)
+
+Primary flow:
+
+- `createCaatingaClient(...)`
+- `client.contract(name).invoke(method, args?)`
+- `client.contract(name).buildXdr(method, args?)`
+
+## Counter Example
+
+```ts
+import { createCaatingaClient } from "@caatinga/client";
+import { freighterWalletAdapter } from "@caatinga/client/freighter";
+import * as Counter from "./contracts/generated/counter";
+import artifacts from "../caatinga.artifacts.json";
+
+const client = createCaatingaClient({
+  network: {
+    name: "testnet",
+    rpcUrl: "https://soroban-testnet.stellar.org",
+    networkPassphrase: "Test SDF Network ; September 2015"
+  },
+  artifacts,
+  wallet: freighterWalletAdapter,
+  contracts: {
+    counter: {
+      binding: Counter
+    }
+  }
+});
+
+const result = await client.contract("counter").invoke("increment");
+```
+
+## Wallet Adapter Contract
+
+```ts
+export interface CaatingaWalletAdapter {
+  getPublicKey(): Promise<string>;
+
+  signTransaction(input: {
+    xdr: string;
+    networkPassphrase: string;
+  }): Promise<string>;
+}
+```
+
+The default Freighter adapter is exported from `@caatinga/client/freighter`.
+
+## Debug Output Rules
+
+- XDR data is omitted by default
+- `debugXdr: true` includes XDR snapshots such as unsigned, prepared, and signed values
+- raw binding or submission output is omitted by default
+- `debugRaw: true` includes raw binding or submission output
+
+Consumers should treat debug fields as opt-in diagnostics, not part of the default happy-path payload.
+
+## Errors
+
+`@caatinga/client` emits documented `CAATINGA_*` codes for public failures. Consumers should key automation on the code, not the message text.
+
+Common codes include:
+
+- `CAATINGA_CONTRACT_ARTIFACT_NOT_FOUND`
+- `CAATINGA_BINDING_CLIENT_NOT_FOUND`
+- `CAATINGA_BINDING_METHOD_NOT_FOUND`
+- `CAATINGA_WALLET_NOT_CONNECTED`
+- `CAATINGA_XDR_BUILD_FAILED`
+- `CAATINGA_XDR_PREPARE_FAILED`
+- `CAATINGA_XDR_SIGN_FAILED`
+- `CAATINGA_XDR_SUBMIT_FAILED`
+- `CAATINGA_XDR_RESULT_FAILED`
+
+## Limitations
+
+- this package does not replace Stellar CLI, Stellar SDK, Soroban SDK, or generated bindings
+- manual SCVal serialization and manual XDR parsing are out of scope
+- React hooks, multisig orchestration, backend signing, and non-documented wallet integrations are not part of the supported contract
+- private module paths and undocumented helpers are less stable than the exports listed above

package/dist/freighter.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/freighter.ts
+var freighter_exports = {};
+__export(freighter_exports, {
+  freighterWalletAdapter: () => freighterWalletAdapter
+});
+module.exports = __toCommonJS(freighter_exports);
+
+// src/adapters/freighter.ts
+var import_freighter_api = require("@stellar/freighter-api");
+var freighterWalletAdapter = {
+  async getPublicKey() {
+    const response = await (0, import_freighter_api.getAddress)();
+    return response.address;
+  },
+  async signTransaction({ xdr, networkPassphrase }) {
+    const response = await (0, import_freighter_api.signTransaction)(xdr, { networkPassphrase });
+    return response.signedTxXdr;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  freighterWalletAdapter
+});

package/dist/freighter.d.cts

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

package/dist/freighter.d.ts

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

package/dist/freighter.js

@@ -0,0 +1,15 @@
+// src/adapters/freighter.ts
+import { getAddress, signTransaction } from "@stellar/freighter-api";
+var freighterWalletAdapter = {
+  async getPublicKey() {
+    const response = await getAddress();
+    return response.address;
+  },
+  async signTransaction({ xdr, networkPassphrase }) {
+    const response = await signTransaction(xdr, { networkPassphrase });
+    return response.signedTxXdr;
+  }
+};
+export {
+  freighterWalletAdapter
+};

package/dist/index.cjs

@@ -0,0 +1,339 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CaatingaContractClient: () => CaatingaContractClient,
+  buildXdr: () => buildXdr,
+  createCaatingaClient: () => createCaatingaClient,
+  createDefaultBindingAdapter: () => createDefaultBindingAdapter,
+  resolveContractId: () => resolveContractId
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/artifacts/resolve-contract-id.ts
+var import_core = require("@caatinga/core");
+function resolveContractId(input) {
+  if (input.explicitContractId) {
+    return input.explicitContractId;
+  }
+  const contractId = input.artifacts.networks[input.network]?.contracts[input.contract]?.contractId;
+  if (contractId) {
+    return contractId;
+  }
+  throw new import_core.CaatingaError(
+    `No contract artifact found for "${input.contract}" on "${input.network}".`,
+    import_core.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");
+function createDefaultBindingAdapter(binding) {
+  return {
+    createClient({ contractId, publicKey, rpcUrl, networkPassphrase }) {
+      if (!binding.Client) {
+        throw new import_core2.CaatingaError(
+          "Generated binding does not export Client.",
+          import_core2.CaatingaErrorCode.BINDING_CLIENT_NOT_FOUND,
+          "Regenerate bindings with Stellar CLI."
+        );
+      }
+      return new binding.Client({
+        contractId,
+        publicKey,
+        rpcUrl,
+        networkPassphrase
+      });
+    },
+    async callMethod({ client, method, args }) {
+      const candidate = client;
+      const fn = candidate[method];
+      if (typeof fn !== "function") {
+        throw new import_core2.CaatingaError(
+          `Binding method "${method}" was not found.`,
+          import_core2.CaatingaErrorCode.BINDING_METHOD_NOT_FOUND,
+          "Check the contract method name or regenerate bindings."
+        );
+      }
+      return args ? fn.call(client, args) : fn.call(client);
+    }
+  };
+}
+
+// src/client/create-caatinga-client.ts
+var import_core5 = require("@caatinga/core");
+
+// src/client/caatinga-contract-client.ts
+var import_core4 = require("@caatinga/core");
+
+// src/xdr/build-xdr.ts
+var import_core3 = require("@caatinga/core");
+async function buildXdr(input) {
+  try {
+    const transaction = input.transaction;
+    const unsignedXdr = readXdr(transaction);
+    let preparedTransaction;
+    if (typeof transaction.prepare === "function") {
+      try {
+        preparedTransaction = await transaction.prepare();
+      } catch (error) {
+        if (error instanceof import_core3.CaatingaError) {
+          throw error;
+        }
+        throw new import_core3.CaatingaError(
+          `Failed to prepare XDR for "${input.contractName}.${input.method}".`,
+          import_core3.CaatingaErrorCode.XDR_PREPARE_FAILED,
+          "Check RPC connectivity, simulation errors, and binding compatibility.",
+          error
+        );
+      }
+    } else {
+      preparedTransaction = transaction;
+    }
+    const preparedXdr = readXdr(preparedTransaction);
+    return {
+      contract: input.contractName,
+      method: input.method,
+      contractId: input.contractId,
+      unsignedXdr,
+      preparedXdr,
+      ...input.debug ? { raw: preparedTransaction } : {}
+    };
+  } catch (error) {
+    if (error instanceof import_core3.CaatingaError) {
+      throw error;
+    }
+    throw new import_core3.CaatingaError(
+      `Failed to build XDR for "${input.contractName}.${input.method}".`,
+      import_core3.CaatingaErrorCode.XDR_BUILD_FAILED,
+      "Check the generated binding transaction object.",
+      error
+    );
+  }
+}
+function readXdr(transaction) {
+  const candidate = transaction;
+  if (typeof candidate.toXDR !== "function") {
+    throw new import_core3.CaatingaError(
+      "Binding transaction object does not expose toXDR().",
+      import_core3.CaatingaErrorCode.XDR_BUILD_FAILED,
+      "Regenerate bindings or provide a compatible binding adapter."
+    );
+  }
+  return candidate.toXDR();
+}
+
+// src/client/caatinga-contract-client.ts
+var CaatingaContractClient = class {
+  constructor(config, contractName, registration, bindingAdapter = createDefaultBindingAdapter(
+    registration.binding
+  )) {
+    this.config = config;
+    this.contractName = contractName;
+    this.registration = registration;
+    this.bindingAdapter = bindingAdapter;
+  }
+  config;
+  contractName;
+  registration;
+  bindingAdapter;
+  async buildXdr(method, argsOrOptions, maybeOptions) {
+    const { args, debugRaw } = splitArgsAndOptions(argsOrOptions, maybeOptions);
+    const { contractId, transaction } = await this.createTransaction(method, args);
+    return buildXdr({
+      contractName: this.contractName,
+      method,
+      contractId,
+      transaction,
+      debug: debugRaw
+    });
+  }
+  async invoke(method, argsOrOptions, maybeOptions) {
+    const { args, debugXdr, debugRaw } = splitInvokeArgsAndOptions(argsOrOptions, maybeOptions);
+    const { contractId, transaction } = await this.createTransaction(method, args);
+    const xdr = await buildXdr({
+      contractName: this.contractName,
+      method,
+      contractId,
+      transaction,
+      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(
+        `Failed to sign XDR for "${this.contractName}.${method}".`,
+        import_core4.CaatingaErrorCode.XDR_SIGN_FAILED,
+        "Connect a wallet and approve the transaction.",
+        error
+      );
+    }
+    const raw = await submitTransaction(transaction, signedXdr, this.contractName, method);
+    const normalized = normalizeSubmitResult(raw);
+    return {
+      status: "confirmed",
+      contract: this.contractName,
+      method,
+      contractId,
+      ...normalized.transactionHash ? { transactionHash: normalized.transactionHash } : {},
+      ...normalized.result !== void 0 ? { result: normalized.result } : {},
+      ...debugXdr ? {
+        xdr: {
+          unsigned: xdr.unsignedXdr,
+          prepared: xdr.preparedXdr,
+          signed: signedXdr
+        }
+      } : {},
+      ...debugRaw ? { raw } : {}
+    };
+  }
+  async createTransaction(method, args) {
+    const contractId = resolveContractId({
+      artifacts: this.config.artifacts,
+      network: this.config.network.name,
+      contract: this.contractName,
+      explicitContractId: this.registration.contractId
+    });
+    let publicKey;
+    try {
+      publicKey = await this.config.wallet.getPublicKey();
+    } catch (error) {
+      if (error instanceof import_core4.CaatingaError) {
+        throw error;
+      }
+      throw new import_core4.CaatingaError(
+        `Wallet is not connected or the public key is unavailable for "${this.contractName}".`,
+        import_core4.CaatingaErrorCode.WALLET_NOT_CONNECTED,
+        "Connect the wallet and grant account access, then retry.",
+        error
+      );
+    }
+    const client = this.bindingAdapter.createClient({
+      contractId,
+      publicKey,
+      rpcUrl: this.config.network.rpcUrl,
+      networkPassphrase: this.config.network.networkPassphrase
+    });
+    const transaction = await this.bindingAdapter.callMethod({ client, method, args });
+    return { contractId, transaction };
+  }
+};
+function splitArgsAndOptions(argsOrOptions, maybeOptions) {
+  return {
+    args: argsOrOptions,
+    debugRaw: maybeOptions?.debugRaw ?? false
+  };
+}
+function splitInvokeArgsAndOptions(argsOrOptions, maybeOptions) {
+  const looksLikeOptions = argsOrOptions !== void 0 && ("debugXdr" in argsOrOptions || "debugRaw" in argsOrOptions) && maybeOptions === void 0;
+  if (looksLikeOptions) {
+    const options = argsOrOptions;
+    return {
+      args: void 0,
+      debugXdr: options.debugXdr ?? false,
+      debugRaw: options.debugRaw ?? false
+    };
+  }
+  return {
+    args: argsOrOptions,
+    debugXdr: maybeOptions?.debugXdr ?? false,
+    debugRaw: maybeOptions?.debugRaw ?? false
+  };
+}
+async function submitTransaction(transaction, signedXdr, contractName, method) {
+  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."
+    );
+  }
+  try {
+    const raw = await submit.call(transaction, { signedXdr });
+    assertSubmitResultRecognized(raw, contractName, method);
+    return raw;
+  } catch (error) {
+    if (error instanceof import_core4.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.",
+      error
+    );
+  }
+}
+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 hasResult = "result" in record;
+  if (hasTransactionId || hasResult) {
+    return;
+  }
+  throw new import_core4.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."
+  );
+}
+function normalizeSubmitResult(raw) {
+  const candidate = raw;
+  return {
+    transactionHash: candidate.txHash ?? candidate.transactionHash ?? candidate.hash,
+    result: candidate.result
+  };
+}
+
+// src/client/create-caatinga-client.ts
+function createCaatingaClient(config) {
+  return {
+    contract(contractName) {
+      const registration = config.contracts[contractName];
+      if (!registration) {
+        throw new import_core5.CaatingaError(
+          `Contract "${contractName}" is not registered.`,
+          import_core5.CaatingaErrorCode.CONTRACT_NOT_FOUND,
+          "Add the contract binding to createCaatingaClient()."
+        );
+      }
+      return new CaatingaContractClient(config, contractName, registration);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CaatingaContractClient,
+  buildXdr,
+  createCaatingaClient,
+  createDefaultBindingAdapter,
+  resolveContractId
+});

package/dist/index.d.cts

@@ -0,0 +1,47 @@
+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';
+
+declare function resolveContractId(input: {
+    artifacts: CaatingaArtifacts;
+    network: string;
+    contract: string;
+    explicitContractId?: string;
+}): string;
+
+interface BindingWithClient {
+    Client?: new (input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }) => unknown;
+}
+declare function createDefaultBindingAdapter(binding: BindingWithClient): CaatingaBindingAdapter;
+
+declare class CaatingaContractClient {
+    private readonly config;
+    private readonly contractName;
+    private readonly registration;
+    private readonly bindingAdapter;
+    constructor(config: CaatingaClientConfig, contractName: string, registration: CaatingaContractRegistration, bindingAdapter?: CaatingaBindingAdapter);
+    buildXdr(method: string, argsOrOptions?: Record<string, unknown>, maybeOptions?: {
+        debugRaw?: boolean;
+    }): Promise<CaatingaXdrBuildResult>;
+    invoke<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaInvokeOptions, maybeOptions?: CaatingaInvokeOptions): Promise<CaatingaInvokeResult<T>>;
+    private createTransaction;
+}
+
+declare function createCaatingaClient(config: CaatingaClientConfig): {
+    contract(contractName: string): CaatingaContractClient;
+};
+
+declare function buildXdr(input: {
+    contractName: string;
+    method: string;
+    contractId: string;
+    transaction: unknown;
+    debug?: boolean;
+}): Promise<CaatingaXdrBuildResult>;
+
+export { CaatingaBindingAdapter, CaatingaClientConfig, CaatingaContractClient, CaatingaContractRegistration, CaatingaInvokeOptions, CaatingaInvokeResult, CaatingaXdrBuildResult, buildXdr, createCaatingaClient, createDefaultBindingAdapter, resolveContractId };

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+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';
+
+declare function resolveContractId(input: {
+    artifacts: CaatingaArtifacts;
+    network: string;
+    contract: string;
+    explicitContractId?: string;
+}): string;
+
+interface BindingWithClient {
+    Client?: new (input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }) => unknown;
+}
+declare function createDefaultBindingAdapter(binding: BindingWithClient): CaatingaBindingAdapter;
+
+declare class CaatingaContractClient {
+    private readonly config;
+    private readonly contractName;
+    private readonly registration;
+    private readonly bindingAdapter;
+    constructor(config: CaatingaClientConfig, contractName: string, registration: CaatingaContractRegistration, bindingAdapter?: CaatingaBindingAdapter);
+    buildXdr(method: string, argsOrOptions?: Record<string, unknown>, maybeOptions?: {
+        debugRaw?: boolean;
+    }): Promise<CaatingaXdrBuildResult>;
+    invoke<T = unknown>(method: string, argsOrOptions?: Record<string, unknown> | CaatingaInvokeOptions, maybeOptions?: CaatingaInvokeOptions): Promise<CaatingaInvokeResult<T>>;
+    private createTransaction;
+}
+
+declare function createCaatingaClient(config: CaatingaClientConfig): {
+    contract(contractName: string): CaatingaContractClient;
+};
+
+declare function buildXdr(input: {
+    contractName: string;
+    method: string;
+    contractId: string;
+    transaction: unknown;
+    debug?: boolean;
+}): Promise<CaatingaXdrBuildResult>;
+
+export { CaatingaBindingAdapter, CaatingaClientConfig, CaatingaContractClient, CaatingaContractRegistration, CaatingaInvokeOptions, CaatingaInvokeResult, CaatingaXdrBuildResult, buildXdr, createCaatingaClient, createDefaultBindingAdapter, resolveContractId };