@caatinga/client 0.2.0

package/dist/index.js

@@ -0,0 +1,308 @@
+// src/artifacts/resolve-contract-id.ts
+import { CaatingaError, CaatingaErrorCode } from "@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 CaatingaError(
+    `No contract artifact found for "${input.contract}" on "${input.network}".`,
+    CaatingaErrorCode.CONTRACT_ARTIFACT_NOT_FOUND,
+    "Deploy the contract first or pass contractId explicitly."
+  );
+}
+
+// src/bindings/default-binding-adapter.ts
+import { CaatingaError as CaatingaError2, CaatingaErrorCode as CaatingaErrorCode2 } from "@caatinga/core";
+function createDefaultBindingAdapter(binding) {
+  return {
+    createClient({ contractId, publicKey, rpcUrl, networkPassphrase }) {
+      if (!binding.Client) {
+        throw new CaatingaError2(
+          "Generated binding does not export Client.",
+          CaatingaErrorCode2.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 CaatingaError2(
+          `Binding method "${method}" was not found.`,
+          CaatingaErrorCode2.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
+import { CaatingaError as CaatingaError5, CaatingaErrorCode as CaatingaErrorCode5 } from "@caatinga/core";
+
+// src/client/caatinga-contract-client.ts
+import { CaatingaError as CaatingaError4, CaatingaErrorCode as CaatingaErrorCode4 } from "@caatinga/core";
+
+// src/xdr/build-xdr.ts
+import { CaatingaError as CaatingaError3, CaatingaErrorCode as CaatingaErrorCode3 } from "@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 CaatingaError3) {
+          throw error;
+        }
+        throw new CaatingaError3(
+          `Failed to prepare XDR for "${input.contractName}.${input.method}".`,
+          CaatingaErrorCode3.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 CaatingaError3) {
+      throw error;
+    }
+    throw new CaatingaError3(
+      `Failed to build XDR for "${input.contractName}.${input.method}".`,
+      CaatingaErrorCode3.XDR_BUILD_FAILED,
+      "Check the generated binding transaction object.",
+      error
+    );
+  }
+}
+function readXdr(transaction) {
+  const candidate = transaction;
+  if (typeof candidate.toXDR !== "function") {
+    throw new CaatingaError3(
+      "Binding transaction object does not expose toXDR().",
+      CaatingaErrorCode3.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 CaatingaError4(
+        `Failed to sign XDR for "${this.contractName}.${method}".`,
+        CaatingaErrorCode4.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 CaatingaError4) {
+        throw error;
+      }
+      throw new CaatingaError4(
+        `Wallet is not connected or the public key is unavailable for "${this.contractName}".`,
+        CaatingaErrorCode4.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 CaatingaError4(
+      `Binding transaction for "${contractName}.${method}" cannot be submitted.`,
+      CaatingaErrorCode4.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 CaatingaError4) {
+      throw error;
+    }
+    throw new CaatingaError4(
+      `Failed to submit XDR for "${contractName}.${method}".`,
+      CaatingaErrorCode4.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 CaatingaError4(
+    `Submit returned an unrecognized payload for "${contractName}.${method}".`,
+    CaatingaErrorCode4.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 CaatingaError5(
+          `Contract "${contractName}" is not registered.`,
+          CaatingaErrorCode5.CONTRACT_NOT_FOUND,
+          "Add the contract binding to createCaatingaClient()."
+        );
+      }
+      return new CaatingaContractClient(config, contractName, registration);
+    }
+  };
+}
+export {
+  CaatingaContractClient,
+  buildXdr,
+  createCaatingaClient,
+  createDefaultBindingAdapter,
+  resolveContractId
+};

package/dist/types-Bmw_J1fg.d.cts

@@ -0,0 +1,66 @@
+import { KaleidoArtifacts } from '@kaleido/core';
+
+interface KaleidoNetwork {
+    name: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+}
+interface KaleidoWalletAdapter {
+    getPublicKey(): Promise<string>;
+    signTransaction(input: {
+        xdr: string;
+        networkPassphrase: string;
+    }): Promise<string>;
+}
+interface KaleidoContractRegistration {
+    binding: unknown;
+    contractId?: string;
+}
+interface KaleidoClientConfig {
+    network: KaleidoNetwork;
+    artifacts: KaleidoArtifacts;
+    wallet: KaleidoWalletAdapter;
+    contracts: Record<string, KaleidoContractRegistration>;
+}
+type KaleidoInvokeStatus = "built" | "prepared" | "signed" | "submitted" | "confirmed" | "failed";
+interface KaleidoInvokeOptions {
+    debugXdr?: boolean;
+    debugRaw?: boolean;
+}
+interface KaleidoInvokeResult<T = unknown> {
+    status: KaleidoInvokeStatus;
+    contract: string;
+    method: string;
+    contractId: string;
+    transactionHash?: string;
+    result?: T;
+    xdr?: {
+        unsigned?: string;
+        prepared?: string;
+        signed?: string;
+    };
+    raw?: unknown;
+}
+interface KaleidoXdrBuildResult {
+    contract: string;
+    method: string;
+    contractId: string;
+    unsignedXdr?: string;
+    preparedXdr: string;
+    raw?: unknown;
+}
+interface KaleidoBindingAdapter {
+    createClient(input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }): unknown;
+    callMethod(input: {
+        client: unknown;
+        method: string;
+        args?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+
+export type { KaleidoWalletAdapter as K, KaleidoBindingAdapter as a, KaleidoClientConfig as b, KaleidoContractRegistration as c, KaleidoXdrBuildResult as d, KaleidoInvokeOptions as e, KaleidoInvokeResult as f, KaleidoInvokeStatus as g, KaleidoNetwork as h };

package/dist/types-Bmw_J1fg.d.ts

@@ -0,0 +1,66 @@
+import { KaleidoArtifacts } from '@kaleido/core';
+
+interface KaleidoNetwork {
+    name: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+}
+interface KaleidoWalletAdapter {
+    getPublicKey(): Promise<string>;
+    signTransaction(input: {
+        xdr: string;
+        networkPassphrase: string;
+    }): Promise<string>;
+}
+interface KaleidoContractRegistration {
+    binding: unknown;
+    contractId?: string;
+}
+interface KaleidoClientConfig {
+    network: KaleidoNetwork;
+    artifacts: KaleidoArtifacts;
+    wallet: KaleidoWalletAdapter;
+    contracts: Record<string, KaleidoContractRegistration>;
+}
+type KaleidoInvokeStatus = "built" | "prepared" | "signed" | "submitted" | "confirmed" | "failed";
+interface KaleidoInvokeOptions {
+    debugXdr?: boolean;
+    debugRaw?: boolean;
+}
+interface KaleidoInvokeResult<T = unknown> {
+    status: KaleidoInvokeStatus;
+    contract: string;
+    method: string;
+    contractId: string;
+    transactionHash?: string;
+    result?: T;
+    xdr?: {
+        unsigned?: string;
+        prepared?: string;
+        signed?: string;
+    };
+    raw?: unknown;
+}
+interface KaleidoXdrBuildResult {
+    contract: string;
+    method: string;
+    contractId: string;
+    unsignedXdr?: string;
+    preparedXdr: string;
+    raw?: unknown;
+}
+interface KaleidoBindingAdapter {
+    createClient(input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }): unknown;
+    callMethod(input: {
+        client: unknown;
+        method: string;
+        args?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+
+export type { KaleidoWalletAdapter as K, KaleidoBindingAdapter as a, KaleidoClientConfig as b, KaleidoContractRegistration as c, KaleidoXdrBuildResult as d, KaleidoInvokeOptions as e, KaleidoInvokeResult as f, KaleidoInvokeStatus as g, KaleidoNetwork as h };

package/dist/types-CND6fcI5.d.cts

@@ -0,0 +1,66 @@
+import { KaleidoArtifacts } from '@kaleido-xlm/core';
+
+interface KaleidoNetwork {
+    name: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+}
+interface KaleidoWalletAdapter {
+    getPublicKey(): Promise<string>;
+    signTransaction(input: {
+        xdr: string;
+        networkPassphrase: string;
+    }): Promise<string>;
+}
+interface KaleidoContractRegistration {
+    binding: unknown;
+    contractId?: string;
+}
+interface KaleidoClientConfig {
+    network: KaleidoNetwork;
+    artifacts: KaleidoArtifacts;
+    wallet: KaleidoWalletAdapter;
+    contracts: Record<string, KaleidoContractRegistration>;
+}
+type KaleidoInvokeStatus = "built" | "prepared" | "signed" | "submitted" | "confirmed" | "failed";
+interface KaleidoInvokeOptions {
+    debugXdr?: boolean;
+    debugRaw?: boolean;
+}
+interface KaleidoInvokeResult<T = unknown> {
+    status: KaleidoInvokeStatus;
+    contract: string;
+    method: string;
+    contractId: string;
+    transactionHash?: string;
+    result?: T;
+    xdr?: {
+        unsigned?: string;
+        prepared?: string;
+        signed?: string;
+    };
+    raw?: unknown;
+}
+interface KaleidoXdrBuildResult {
+    contract: string;
+    method: string;
+    contractId: string;
+    unsignedXdr?: string;
+    preparedXdr: string;
+    raw?: unknown;
+}
+interface KaleidoBindingAdapter {
+    createClient(input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }): unknown;
+    callMethod(input: {
+        client: unknown;
+        method: string;
+        args?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+
+export type { KaleidoWalletAdapter as K, KaleidoBindingAdapter as a, KaleidoClientConfig as b, KaleidoContractRegistration as c, KaleidoXdrBuildResult as d, KaleidoInvokeOptions as e, KaleidoInvokeResult as f, KaleidoInvokeStatus as g, KaleidoNetwork as h };

package/dist/types-CND6fcI5.d.ts

@@ -0,0 +1,66 @@
+import { KaleidoArtifacts } from '@kaleido-xlm/core';
+
+interface KaleidoNetwork {
+    name: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+}
+interface KaleidoWalletAdapter {
+    getPublicKey(): Promise<string>;
+    signTransaction(input: {
+        xdr: string;
+        networkPassphrase: string;
+    }): Promise<string>;
+}
+interface KaleidoContractRegistration {
+    binding: unknown;
+    contractId?: string;
+}
+interface KaleidoClientConfig {
+    network: KaleidoNetwork;
+    artifacts: KaleidoArtifacts;
+    wallet: KaleidoWalletAdapter;
+    contracts: Record<string, KaleidoContractRegistration>;
+}
+type KaleidoInvokeStatus = "built" | "prepared" | "signed" | "submitted" | "confirmed" | "failed";
+interface KaleidoInvokeOptions {
+    debugXdr?: boolean;
+    debugRaw?: boolean;
+}
+interface KaleidoInvokeResult<T = unknown> {
+    status: KaleidoInvokeStatus;
+    contract: string;
+    method: string;
+    contractId: string;
+    transactionHash?: string;
+    result?: T;
+    xdr?: {
+        unsigned?: string;
+        prepared?: string;
+        signed?: string;
+    };
+    raw?: unknown;
+}
+interface KaleidoXdrBuildResult {
+    contract: string;
+    method: string;
+    contractId: string;
+    unsignedXdr?: string;
+    preparedXdr: string;
+    raw?: unknown;
+}
+interface KaleidoBindingAdapter {
+    createClient(input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }): unknown;
+    callMethod(input: {
+        client: unknown;
+        method: string;
+        args?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+
+export type { KaleidoWalletAdapter as K, KaleidoBindingAdapter as a, KaleidoClientConfig as b, KaleidoContractRegistration as c, KaleidoXdrBuildResult as d, KaleidoInvokeOptions as e, KaleidoInvokeResult as f, KaleidoInvokeStatus as g, KaleidoNetwork as h };

package/dist/types-CiM5FkDn.d.cts

@@ -0,0 +1,66 @@
+import { CaatingaArtifacts } from '@caatinga/core';
+
+interface CaatingaNetwork {
+    name: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+}
+interface CaatingaWalletAdapter {
+    getPublicKey(): Promise<string>;
+    signTransaction(input: {
+        xdr: string;
+        networkPassphrase: string;
+    }): Promise<string>;
+}
+interface CaatingaContractRegistration {
+    binding: unknown;
+    contractId?: string;
+}
+interface CaatingaClientConfig {
+    network: CaatingaNetwork;
+    artifacts: CaatingaArtifacts;
+    wallet: CaatingaWalletAdapter;
+    contracts: Record<string, CaatingaContractRegistration>;
+}
+type CaatingaInvokeStatus = "built" | "prepared" | "signed" | "submitted" | "confirmed" | "failed";
+interface CaatingaInvokeOptions {
+    debugXdr?: boolean;
+    debugRaw?: boolean;
+}
+interface CaatingaInvokeResult<T = unknown> {
+    status: CaatingaInvokeStatus;
+    contract: string;
+    method: string;
+    contractId: string;
+    transactionHash?: string;
+    result?: T;
+    xdr?: {
+        unsigned?: string;
+        prepared?: string;
+        signed?: string;
+    };
+    raw?: unknown;
+}
+interface CaatingaXdrBuildResult {
+    contract: string;
+    method: string;
+    contractId: string;
+    unsignedXdr?: string;
+    preparedXdr: string;
+    raw?: unknown;
+}
+interface CaatingaBindingAdapter {
+    createClient(input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }): unknown;
+    callMethod(input: {
+        client: unknown;
+        method: string;
+        args?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+
+export type { CaatingaWalletAdapter as C, CaatingaBindingAdapter as a, CaatingaClientConfig as b, CaatingaContractRegistration as c, CaatingaXdrBuildResult as d, CaatingaInvokeOptions as e, CaatingaInvokeResult as f, CaatingaInvokeStatus as g, CaatingaNetwork as h };

package/dist/types-CiM5FkDn.d.ts

@@ -0,0 +1,66 @@
+import { CaatingaArtifacts } from '@caatinga/core';
+
+interface CaatingaNetwork {
+    name: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+}
+interface CaatingaWalletAdapter {
+    getPublicKey(): Promise<string>;
+    signTransaction(input: {
+        xdr: string;
+        networkPassphrase: string;
+    }): Promise<string>;
+}
+interface CaatingaContractRegistration {
+    binding: unknown;
+    contractId?: string;
+}
+interface CaatingaClientConfig {
+    network: CaatingaNetwork;
+    artifacts: CaatingaArtifacts;
+    wallet: CaatingaWalletAdapter;
+    contracts: Record<string, CaatingaContractRegistration>;
+}
+type CaatingaInvokeStatus = "built" | "prepared" | "signed" | "submitted" | "confirmed" | "failed";
+interface CaatingaInvokeOptions {
+    debugXdr?: boolean;
+    debugRaw?: boolean;
+}
+interface CaatingaInvokeResult<T = unknown> {
+    status: CaatingaInvokeStatus;
+    contract: string;
+    method: string;
+    contractId: string;
+    transactionHash?: string;
+    result?: T;
+    xdr?: {
+        unsigned?: string;
+        prepared?: string;
+        signed?: string;
+    };
+    raw?: unknown;
+}
+interface CaatingaXdrBuildResult {
+    contract: string;
+    method: string;
+    contractId: string;
+    unsignedXdr?: string;
+    preparedXdr: string;
+    raw?: unknown;
+}
+interface CaatingaBindingAdapter {
+    createClient(input: {
+        contractId: string;
+        publicKey: string;
+        rpcUrl: string;
+        networkPassphrase: string;
+    }): unknown;
+    callMethod(input: {
+        client: unknown;
+        method: string;
+        args?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+
+export type { CaatingaWalletAdapter as C, CaatingaBindingAdapter as a, CaatingaClientConfig as b, CaatingaContractRegistration as c, CaatingaXdrBuildResult as d, CaatingaInvokeOptions as e, CaatingaInvokeResult as f, CaatingaInvokeStatus as g, CaatingaNetwork as h };