@digitalworld/digital-world-sdk 16.0.0

package/lib/axios/esm/contract/rust_result.js

@@ -0,0 +1,39 @@
+class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  unwrapErr() {
+    throw new Error("No error");
+  }
+  unwrap() {
+    return this.value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return false;
+  }
+}
+class Err {
+  constructor(error) {
+    this.error = error;
+  }
+  error;
+  unwrapErr() {
+    return this.error;
+  }
+  unwrap() {
+    throw new Error(this.error.message);
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return true;
+  }
+}
+
+export { Err, Ok };
+//# sourceMappingURL=rust_result.js.map

package/lib/axios/esm/contract/rust_result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust_result.js","sources":["../../../../src/contract/rust_result.ts"],"sourcesContent":["/* disable max-classes rule, because extending error shouldn't count! */\n/* eslint max-classes-per-file: 0 */\n\n/**\n * A minimal implementation of Rust's `Result` type. Used for contract\n * methods that return Results, to maintain their distinction from methods\n * that simply either return a value or throw.\n *\n * #### Why is this needed?\n *\n * This is used by {@link contract.Spec | `ContractSpec`} and\n * {@link contract.AssembledTransaction | `AssembledTransaction`} when\n * parsing values return by contracts.\n *\n * Contract methods can be implemented to return simple values, in which case\n * they can also throw errors. This matches JavaScript's most idiomatic\n * workflow, using `try...catch` blocks.\n *\n * But Rust also gives the flexibility of returning `Result` types. And Soroban\n * contracts further support this with the `#[contracterror]` macro. Should\n * JavaScript calls to such methods ignore all of that, and just flatten this\n * extra info down to the same `try...catch` flow as other methods? We're not\n * sure.\n *\n * For now, we've added this minimal implementation of Rust's `Result` logic,\n * which exports the `Result` interface and its associated implementations,\n * `Ok` and `Err`. This allows `ContractSpec` and `AssembledTransaction` to\n * work together to duplicate the contract's Rust logic, always returning\n * `Result` types for contract methods that are implemented to do so.\n *\n * In the future, if this feels too un-idiomatic for JavaScript, we can always\n * remove this and flatten all JS calls to `try...catch`. Easier to remove this\n * logic later than it would be to add it.\n *\n */\nexport interface Result<T, E extends ErrorMessage = ErrorMessage> {\n  unwrap(): T;\n  unwrapErr(): E;\n  isOk(): boolean;\n  isErr(): boolean;\n}\n\n/**\n * Error interface containing the error message. Matches Rust's implementation.\n * Part of implementing {@link contract.Result | Result}, a minimal\n * implementation of Rust's `Result` type. Used for contract methods that return\n * Results, to maintain their distinction from methods that simply either return\n * a value or throw.\n *\n */\nexport interface ErrorMessage {\n  message: string;\n}\n\n/**\n * Part of implementing {@link contract.Result | Result}, a minimal\n * implementation of Rust's `Result` type. Used for contract methods that return\n * Results, to maintain their distinction from methods that simply either return\n * a value or throw.\n * @hidden\n */\nexport class Ok<T> implements Result<T, never> {\n  constructor(readonly value: T) {}\n\n  unwrapErr(): never {\n    throw new Error(\"No error\");\n  }\n\n  unwrap() {\n    return this.value;\n  }\n\n  isOk() {\n    return true;\n  }\n\n  isErr() {\n    return false;\n  }\n}\n\n/**\n * Part of implementing {@link contract.Result | Result}, a minimal\n * implementation of Rust's `Result` type. Used for contract methods that return\n * Results, to maintain their distinction from methods that simply either return\n * a value or throw.\n * @hidden\n */\nexport class Err<E extends ErrorMessage> implements Result<never, E> {\n  constructor(readonly error: E) {}\n\n  unwrapErr() {\n    return this.error;\n  }\n\n  unwrap(): never {\n    throw new Error(this.error.message);\n  }\n\n  isOk() {\n    return false;\n  }\n\n  isErr() {\n    return true;\n  }\n}\n"],"names":[],"mappings":"AA6DO,MAAM,EAAA,CAAkC;AAAA,EAC7C,YAAqB,KAAA,EAAU;AAAV,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAAW;AAAA,EAAX,KAAA;AAAA,EAErB,SAAA,GAAmB;AACjB,IAAA,MAAM,IAAI,MAAM,UAAU,CAAA;AAAA,EAC5B;AAAA,EAEA,MAAA,GAAS;AACP,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAAA,EAEA,IAAA,GAAO;AACL,IAAA,OAAO,IAAA;AAAA,EACT;AAAA,EAEA,KAAA,GAAQ;AACN,IAAA,OAAO,KAAA;AAAA,EACT;AACF;AASO,MAAM,GAAA,CAAwD;AAAA,EACnE,YAAqB,KAAA,EAAU;AAAV,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAAW;AAAA,EAAX,KAAA;AAAA,EAErB,SAAA,GAAY;AACV,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAAA,EAEA,MAAA,GAAgB;AACd,IAAA,MAAM,IAAI,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,OAAO,CAAA;AAAA,EACpC;AAAA,EAEA,IAAA,GAAO;AACL,IAAA,OAAO,KAAA;AAAA,EACT;AAAA,EAEA,KAAA,GAAQ;AACN,IAAA,OAAO,IAAA;AAAA,EACT;AACF;;;;"}

package/lib/axios/esm/contract/sent_transaction.d.ts

@@ -0,0 +1,118 @@
+import { Server } from "../rpc/index.js";
+import { Api } from "../rpc/api.js";
+import type { AssembledTransaction } from "./assembled_transaction.js";
+/**
+ * A transaction that has been sent to the Soroban network. This happens in two steps:
+ *
+ * 1. `sendTransaction`: initial submission of the transaction to the network.
+ *    If this step runs into problems, the attempt to sign and send will be
+ *    aborted. You can see the result of this call in the
+ *    `sendTransactionResponse` getter.
+ * 2. `getTransaction`: once the transaction has been submitted to the network
+ *    successfully, you need to wait for it to finalize to get the result of the
+ *    transaction. This will be retried with exponential backoff for
+ *    {@link MethodOptions.timeoutInSeconds} seconds. See all attempts in
+ *    `getTransactionResponseAll` and the most recent attempt in
+ *    `getTransactionResponse`.
+ *
+ *
+ * @param signTransaction - More info in {@link MethodOptions}
+ * @param assembled - {@link AssembledTransaction} from which this SentTransaction was initialized
+ */
+export declare class SentTransaction<T> {
+    assembled: AssembledTransaction<T>;
+    server: Server;
+    /**
+     * The result of calling `sendTransaction` to broadcast the transaction to the
+     * network.
+     */
+    sendTransactionResponse?: Api.SendTransactionResponse;
+    /**
+     * If `sendTransaction` completes successfully (which means it has `status: 'PENDING'`),
+     * then `getTransaction` will be called in a loop for
+     * {@link MethodOptions.timeoutInSeconds} seconds. This array contains all
+     * the results of those calls.
+     */
+    getTransactionResponseAll?: Api.GetTransactionResponse[];
+    /**
+     * The most recent result of calling `getTransaction`, from the
+     * `getTransactionResponseAll` array.
+     */
+    getTransactionResponse?: Api.GetTransactionResponse;
+    static Errors: {
+        SendFailed: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            new (message?: string, options?: ErrorOptions): {
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        SendResultOnly: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            new (message?: string, options?: ErrorOptions): {
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        TransactionStillPending: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            new (message?: string, options?: ErrorOptions): {
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+    };
+    constructor(assembled: AssembledTransaction<T>);
+    /**
+     * Initialize a `SentTransaction` from {@link AssembledTransaction}
+     * `assembled`, passing an optional {@link Watcher} `watcher`. This will also
+     * send the transaction to the network.
+     */
+    static init: <U>(
+    /** {@link AssembledTransaction} from which this SentTransaction was initialized */
+    assembled: AssembledTransaction<U>, watcher?: Watcher) => Promise<SentTransaction<U>>;
+    private send;
+    get result(): T;
+}
+export declare abstract class Watcher {
+    /**
+     * Function to call after transaction has been submitted successfully to
+     * the network for processing
+     */
+    abstract onSubmitted?(response?: Api.SendTransactionResponse): void;
+    /**
+     * Function to call every time the submitted transaction's status is
+     * checked while awaiting its full inclusion in the ledger
+     */
+    abstract onProgress?(response?: Api.GetTransactionResponse): void;
+}

package/lib/axios/esm/contract/sent_transaction.js

@@ -0,0 +1,141 @@
+import { Api } from '../rpc/api.js';
+import { RpcServer } from '../rpc/server.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js';
+import 'buffer';
+import '../base/generated/curr_generated.js';
+import '@noble/hashes/sha2.js';
+import '../base/signing.js';
+import '../base/keypair.js';
+import 'base32.js';
+import '../base/util/continued_fraction.js';
+import '../base/util/bignumber.js';
+import '../base/transaction_builder.js';
+import '../base/muxed_account.js';
+import '../base/scval.js';
+import '../base/numbers/uint128.js';
+import '../base/numbers/uint256.js';
+import '../base/numbers/int128.js';
+import '../base/numbers/int256.js';
+import { withExponentialBackoff } from './utils.js';
+import { DEFAULT_TIMEOUT } from './types.js';
+
+class SentTransaction {
+  constructor(assembled) {
+    this.assembled = assembled;
+    const { server, allowHttp, headers, rpcUrl } = this.assembled.options;
+    this.server = server ?? new RpcServer(rpcUrl, { allowHttp, headers });
+  }
+  assembled;
+  server;
+  /**
+   * The result of calling `sendTransaction` to broadcast the transaction to the
+   * network.
+   */
+  sendTransactionResponse;
+  /**
+   * If `sendTransaction` completes successfully (which means it has `status: 'PENDING'`),
+   * then `getTransaction` will be called in a loop for
+   * {@link MethodOptions.timeoutInSeconds} seconds. This array contains all
+   * the results of those calls.
+   */
+  getTransactionResponseAll;
+  /**
+   * The most recent result of calling `getTransaction`, from the
+   * `getTransactionResponseAll` array.
+   */
+  getTransactionResponse;
+  static Errors = {
+    SendFailed: class SendFailedError extends Error {
+    },
+    SendResultOnly: class SendResultOnlyError extends Error {
+    },
+    TransactionStillPending: class TransactionStillPendingError extends Error {
+    }
+  };
+  /**
+   * Initialize a `SentTransaction` from {@link AssembledTransaction}
+   * `assembled`, passing an optional {@link Watcher} `watcher`. This will also
+   * send the transaction to the network.
+   */
+  static init = async (assembled, watcher) => {
+    const tx = new SentTransaction(assembled);
+    const sent = await tx.send(watcher);
+    return sent;
+  };
+  send = async (watcher) => {
+    this.sendTransactionResponse = await this.server.sendTransaction(
+      this.assembled.signed
+    );
+    if (this.sendTransactionResponse.status !== "PENDING") {
+      throw new SentTransaction.Errors.SendFailed(
+        `Sending the transaction to the network failed!
+${JSON.stringify(
+          this.sendTransactionResponse,
+          null,
+          2
+        )}`
+      );
+    }
+    if (watcher?.onSubmitted) watcher.onSubmitted(this.sendTransactionResponse);
+    const { hash } = this.sendTransactionResponse;
+    const timeoutInSeconds = this.assembled.options.timeoutInSeconds ?? DEFAULT_TIMEOUT;
+    this.getTransactionResponseAll = await withExponentialBackoff(
+      async () => {
+        const tx = await this.server.getTransaction(hash);
+        if (watcher?.onProgress) watcher.onProgress(tx);
+        return tx;
+      },
+      (resp) => resp.status === Api.GetTransactionStatus.NOT_FOUND,
+      timeoutInSeconds
+    );
+    this.getTransactionResponse = this.getTransactionResponseAll[this.getTransactionResponseAll.length - 1];
+    if (this.getTransactionResponse.status === Api.GetTransactionStatus.NOT_FOUND) {
+      throw new SentTransaction.Errors.TransactionStillPending(
+        `Waited ${timeoutInSeconds} seconds for transaction to complete, but it did not. Returning anyway. Check the transaction status manually. Sent transaction: ${JSON.stringify(
+          this.sendTransactionResponse,
+          null,
+          2
+        )}
+All attempts to get the result: ${JSON.stringify(
+          this.getTransactionResponseAll,
+          null,
+          2
+        )}`
+      );
+    }
+    return this;
+  };
+  get result() {
+    if ("getTransactionResponse" in this && this.getTransactionResponse) {
+      if ("returnValue" in this.getTransactionResponse) {
+        return this.assembled.options.parseResultXdr(
+          this.getTransactionResponse.returnValue
+        );
+      }
+      throw new Error("Transaction failed! Cannot parse result.");
+    }
+    if (this.sendTransactionResponse) {
+      const errorResult = this.sendTransactionResponse.errorResult?.result();
+      if (errorResult) {
+        throw new SentTransaction.Errors.SendFailed(
+          `Transaction simulation looked correct, but attempting to send the transaction failed. Check \`simulation\` and \`sendTransactionResponseAll\` to troubleshoot. Decoded \`sendTransactionResponse.errorResultXdr\`: ${errorResult}`
+        );
+      }
+      throw new SentTransaction.Errors.SendResultOnly(
+        `Transaction was sent to the network, but not yet awaited. No result to show. Await transaction completion with \`getTransaction(sendTransactionResponse.hash)\``
+      );
+    }
+    throw new Error(
+      `Sending transaction failed: ${JSON.stringify(this.assembled.signed)}`
+    );
+  }
+}
+class Watcher {
+}
+
+export { SentTransaction, Watcher };
+//# sourceMappingURL=sent_transaction.js.map

package/lib/axios/esm/contract/sent_transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sent_transaction.js","sources":["../../../../src/contract/sent_transaction.ts"],"sourcesContent":["/* disable max-classes rule, because extending error shouldn't count! */\n/* eslint max-classes-per-file: 0 */\nimport type { MethodOptions } from \"./types.js\";\nimport { Server } from \"../rpc/index.js\";\nimport { Api } from \"../rpc/api.js\";\nimport { withExponentialBackoff } from \"./utils.js\";\nimport { DEFAULT_TIMEOUT } from \"./types.js\";\nimport type { AssembledTransaction } from \"./assembled_transaction.js\";\n\n/**\n * A transaction that has been sent to the Soroban network. This happens in two steps:\n *\n * 1. `sendTransaction`: initial submission of the transaction to the network.\n *    If this step runs into problems, the attempt to sign and send will be\n *    aborted. You can see the result of this call in the\n *    `sendTransactionResponse` getter.\n * 2. `getTransaction`: once the transaction has been submitted to the network\n *    successfully, you need to wait for it to finalize to get the result of the\n *    transaction. This will be retried with exponential backoff for\n *    {@link MethodOptions.timeoutInSeconds} seconds. See all attempts in\n *    `getTransactionResponseAll` and the most recent attempt in\n *    `getTransactionResponse`.\n *\n *\n * @param signTransaction - More info in {@link MethodOptions}\n * @param assembled - {@link AssembledTransaction} from which this SentTransaction was initialized\n */\nexport class SentTransaction<T> {\n  public server: Server;\n\n  /**\n   * The result of calling `sendTransaction` to broadcast the transaction to the\n   * network.\n   */\n  public sendTransactionResponse?: Api.SendTransactionResponse;\n\n  /**\n   * If `sendTransaction` completes successfully (which means it has `status: 'PENDING'`),\n   * then `getTransaction` will be called in a loop for\n   * {@link MethodOptions.timeoutInSeconds} seconds. This array contains all\n   * the results of those calls.\n   */\n  public getTransactionResponseAll?: Api.GetTransactionResponse[];\n\n  /**\n   * The most recent result of calling `getTransaction`, from the\n   * `getTransactionResponseAll` array.\n   */\n  public getTransactionResponse?: Api.GetTransactionResponse;\n\n  static Errors = {\n    SendFailed: class SendFailedError extends Error {},\n    SendResultOnly: class SendResultOnlyError extends Error {},\n    TransactionStillPending: class TransactionStillPendingError extends Error {},\n  };\n\n  constructor(public assembled: AssembledTransaction<T>) {\n    const { server, allowHttp, headers, rpcUrl } = this.assembled.options;\n    this.server = server ?? new Server(rpcUrl, { allowHttp, headers });\n  }\n\n  /**\n   * Initialize a `SentTransaction` from {@link AssembledTransaction}\n   * `assembled`, passing an optional {@link Watcher} `watcher`. This will also\n   * send the transaction to the network.\n   */\n  static init = async <U>(\n    /** {@link AssembledTransaction} from which this SentTransaction was initialized */\n    assembled: AssembledTransaction<U>,\n    watcher?: Watcher,\n  ): Promise<SentTransaction<U>> => {\n    const tx = new SentTransaction(assembled);\n    const sent = await tx.send(watcher);\n    return sent;\n  };\n\n  private send = async (watcher?: Watcher): Promise<this> => {\n    this.sendTransactionResponse = await this.server.sendTransaction(\n      this.assembled.signed!,\n    );\n\n    if (this.sendTransactionResponse.status !== \"PENDING\") {\n      throw new SentTransaction.Errors.SendFailed(\n        `Sending the transaction to the network failed!\\n${JSON.stringify(\n          this.sendTransactionResponse,\n          null,\n          2,\n        )}`,\n      );\n    }\n\n    if (watcher?.onSubmitted) watcher.onSubmitted(this.sendTransactionResponse);\n\n    const { hash } = this.sendTransactionResponse;\n\n    const timeoutInSeconds =\n      this.assembled.options.timeoutInSeconds ?? DEFAULT_TIMEOUT;\n    this.getTransactionResponseAll = await withExponentialBackoff(\n      async () => {\n        const tx = await this.server.getTransaction(hash);\n        if (watcher?.onProgress) watcher.onProgress(tx);\n        return tx;\n      },\n      (resp) => resp.status === Api.GetTransactionStatus.NOT_FOUND,\n      timeoutInSeconds,\n    );\n\n    this.getTransactionResponse =\n      this.getTransactionResponseAll[this.getTransactionResponseAll.length - 1];\n    if (\n      this.getTransactionResponse.status === Api.GetTransactionStatus.NOT_FOUND\n    ) {\n      throw new SentTransaction.Errors.TransactionStillPending(\n        `Waited ${timeoutInSeconds} seconds for transaction to complete, but it did not. ` +\n          `Returning anyway. Check the transaction status manually. ` +\n          `Sent transaction: ${JSON.stringify(\n            this.sendTransactionResponse,\n            null,\n            2,\n          )}\\n` +\n          `All attempts to get the result: ${JSON.stringify(\n            this.getTransactionResponseAll,\n            null,\n            2,\n          )}`,\n      );\n    }\n\n    return this;\n  };\n\n  get result(): T {\n    // 1. check if transaction was submitted and awaited with `getTransaction`\n    if (\"getTransactionResponse\" in this && this.getTransactionResponse) {\n      // getTransactionResponse has a `returnValue` field unless it failed\n      if (\"returnValue\" in this.getTransactionResponse) {\n        return this.assembled.options.parseResultXdr(\n          this.getTransactionResponse.returnValue!,\n        );\n      }\n\n      // if \"returnValue\" not present, the transaction failed; return without\n      // parsing the result\n      throw new Error(\"Transaction failed! Cannot parse result.\");\n    }\n\n    // 2. otherwise, maybe it was merely sent with `sendTransaction`\n    if (this.sendTransactionResponse) {\n      const errorResult = this.sendTransactionResponse.errorResult?.result();\n      if (errorResult) {\n        throw new SentTransaction.Errors.SendFailed(\n          `Transaction simulation looked correct, but attempting to send the transaction failed. Check \\`simulation\\` and \\`sendTransactionResponseAll\\` to troubleshoot. Decoded \\`sendTransactionResponse.errorResultXdr\\`: ${errorResult}`,\n        );\n      }\n      throw new SentTransaction.Errors.SendResultOnly(\n        `Transaction was sent to the network, but not yet awaited. No result to show. Await transaction completion with \\`getTransaction(sendTransactionResponse.hash)\\``,\n      );\n    }\n\n    // 3. finally, if neither of those are present, throw an error\n    throw new Error(\n      `Sending transaction failed: ${JSON.stringify(this.assembled.signed)}`,\n    );\n  }\n}\n\nexport abstract class Watcher {\n  /**\n   * Function to call after transaction has been submitted successfully to\n   * the network for processing\n   */\n  abstract onSubmitted?(response?: Api.SendTransactionResponse): void;\n\n  /**\n   * Function to call every time the submitted transaction's status is\n   * checked while awaiting its full inclusion in the ledger\n   */\n  abstract onProgress?(response?: Api.GetTransactionResponse): void;\n}\n"],"names":["Server"],"mappings":"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"}

package/lib/axios/esm/contract/spec.d.ts

@@ -0,0 +1,176 @@
+import type { JSONSchema7 } from "json-schema";
+import { xdr } from "../base/index.js";
+export interface Union<T> {
+    tag: string;
+    values?: T;
+}
+/**
+ * Provides a ContractSpec class which can contains the XDR types defined by the contract.
+ * This allows the class to be used to convert between native and raw `xdr.ScVal`s.
+ *
+ * Constructs a new ContractSpec from an array of XDR spec entries.
+ *
+ * @param entries - the XDR spec entries
+ * @throws if entries is invalid
+ *
+ * @example
+ * ```ts
+ * const specEntries = [...]; // XDR spec entries of a smart contract
+ * const contractSpec = new ContractSpec(specEntries);
+ *
+ * // Convert native value to ScVal
+ * const args = {
+ *   arg1: 'value1',
+ *   arg2: 1234
+ * };
+ * const scArgs = contractSpec.funcArgsToScVals('funcName', args);
+ *
+ * // Call contract
+ * const resultScv = await callContract(contractId, 'funcName', scArgs);
+ *
+ * // Convert result ScVal back to native value
+ * const result = contractSpec.funcResToNative('funcName', resultScv);
+ *
+ * console.log(result); // {success: true}
+ * ```
+ */
+export declare class Spec {
+    /**
+     * The XDR spec entries.
+     */
+    entries: xdr.ScSpecEntry[];
+    /**
+     * Generates a Spec instance from the contract's wasm binary.
+     *
+     * @param wasm - The contract's wasm binary as a Buffer.
+     * @returns A Promise that resolves to a Spec instance.
+     * @throws If the contract spec cannot be obtained from the provided wasm binary.
+     */
+    static fromWasm(wasm: Buffer): Spec;
+    /**
+     * Generates a Spec instance from contract specs in any of the following forms:
+     * - An XDR encoded stream of xdr.ScSpecEntry entries, the format of the spec
+     *   stored inside Wasm files.
+     * - A base64 XDR encoded stream of xdr.ScSpecEntry entries.
+     * - An array of xdr.ScSpecEntry.
+     * - An array of base64 XDR encoded xdr.ScSpecEntry.
+     *
+     * @returns A Promise that resolves to a Client instance.
+     * @throws If the contract spec cannot be obtained from the provided wasm binary.
+     */
+    constructor(entries: Buffer | string | xdr.ScSpecEntry[] | string[]);
+    /**
+     * Gets the XDR functions from the spec.
+     * @returns all contract functions
+     */
+    funcs(): xdr.ScSpecFunctionV0[];
+    /**
+     * Gets the XDR function spec for the given function name.
+     *
+     * @param name - the name of the function
+     * @returns the function spec
+     *
+     * @throws if no function with the given name exists
+     */
+    getFunc(name: string): xdr.ScSpecFunctionV0;
+    /**
+     * Converts native JS arguments to ScVals for calling a contract function.
+     *
+     * @param name - the name of the function
+     * @param args - the arguments object
+     * @returns the converted arguments
+     *
+     * @throws if argument is missing or incorrect type
+     *
+     * @example
+     * ```ts
+     * const args = {
+     *   arg1: 'value1',
+     *   arg2: 1234
+     * };
+     * const scArgs = contractSpec.funcArgsToScVals('funcName', args);
+     * ```
+     */
+    funcArgsToScVals(name: string, args: object): xdr.ScVal[];
+    /**
+     * Converts the result ScVal of a function call to a native JS value.
+     *
+     * @param name - the name of the function
+     * @param val_or_base64 - the result ScVal or base64 encoded string
+     * @returns the converted native value
+     *
+     * @throws if return type mismatch or invalid input
+     *
+     * @example
+     * ```ts
+     * const resultScv = 'AAA=='; // Base64 encoded ScVal
+     * const result = contractSpec.funcResToNative('funcName', resultScv);
+     * ```
+     */
+    funcResToNative(name: string, val_or_base64: xdr.ScVal | string): any;
+    /**
+     * Finds the XDR spec entry for the given name.
+     *
+     * @param name - the name to find
+     * @returns the entry
+     *
+     * @throws if no entry with the given name exists
+     */
+    findEntry(name: string): xdr.ScSpecEntry;
+    /**
+     * Converts a native JS value to an ScVal based on the given type.
+     *
+     * @param val - the native JS value
+     * @param ty - (optional) the expected type
+     * @returns the converted ScVal
+     *
+     * @throws if value cannot be converted to the given type
+     */
+    nativeToScVal(val: any, ty: xdr.ScSpecTypeDef): xdr.ScVal;
+    private nativeToUdt;
+    private nativeToUnion;
+    private nativeToStruct;
+    private nativeToEnum;
+    /**
+     * Converts an base64 encoded ScVal back to a native JS value based on the given type.
+     *
+     * @param scv - the base64 encoded ScVal
+     * @param typeDef - the expected type
+     * @returns the converted native JS value
+     *
+     * @throws if ScVal cannot be converted to the given type
+     */
+    scValStrToNative<T>(scv: string, typeDef: xdr.ScSpecTypeDef): T;
+    /**
+     * Converts an ScVal back to a native JS value based on the given type.
+     *
+     * @param scv - the ScVal
+     * @param typeDef - the expected type
+     * @returns the converted native JS value
+     *
+     * @throws if ScVal cannot be converted to the given type
+     */
+    scValToNative<T>(scv: xdr.ScVal, typeDef: xdr.ScSpecTypeDef): T;
+    private scValUdtToNative;
+    private unionToNative;
+    private structToNative;
+    private enumToNative;
+    /**
+     * Gets the XDR error cases from the spec.
+     *
+     * @returns all contract functions
+     *
+     */
+    errorCases(): xdr.ScSpecUdtErrorEnumCaseV0[];
+    /**
+     * Converts the contract spec to a JSON schema.
+     *
+     * If `funcName` is provided, the schema will be a reference to the function schema.
+     *
+     * @param funcName - (optional) the name of the function to convert
+     * @returns the converted JSON schema
+     *
+     * @throws if the contract spec is invalid
+     */
+    jsonSchema(funcName?: string): JSONSchema7;
+}