wowok 1.8.2 → 2.1.9

package/dist/cjs/cryptography/signature.js

@@ -0,0 +1,71 @@
+"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);
+var signature_exports = {};
+__export(signature_exports, {
+  parseSerializedSignature: () => parseSerializedSignature,
+  toSerializedSignature: () => toSerializedSignature
+});
+module.exports = __toCommonJS(signature_exports);
+var import_bcs = require("@mysten/bcs");
+var import_bcs2 = require("../bcs/index.js");
+var import_publickey = require("../keypairs/passkey/publickey.js");
+var import_publickey2 = require("./publickey.js");
+var import_signature_scheme = require("./signature-scheme.js");
+function toSerializedSignature({
+  signature,
+  signatureScheme,
+  publicKey
+}) {
+  if (!publicKey) {
+    throw new Error("`publicKey` is required");
+  }
+  const pubKeyBytes = publicKey.toRawBytes();
+  const serializedSignature = new Uint8Array(
+    1 + signature.length + pubKeyBytes.length
+  );
+  serializedSignature.set([import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);
+  serializedSignature.set(signature, 1);
+  serializedSignature.set(pubKeyBytes, 1 + signature.length);
+  return (0, import_bcs.toBase64)(serializedSignature);
+}
+function parseSerializedSignature(serializedSignature) {
+  const bytes = (0, import_bcs.fromBase64)(serializedSignature);
+  const signatureScheme = import_signature_scheme.SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+  switch (signatureScheme) {
+    case "Passkey":
+      return (0, import_publickey.parseSerializedPasskeySignature)(serializedSignature);
+    case "MultiSig":
+      const multisig = import_bcs2.bcs.MultiSig.parse(bytes.slice(1));
+      return {
+        serializedSignature,
+        signatureScheme,
+        multisig,
+        bytes,
+        signature: void 0
+      };
+    case "ZkLogin":
+      throw new Error("ZkLogin signature scheme is not supported");
+    case "ED25519":
+    case "Secp256k1":
+    case "Secp256r1":
+      return (0, import_publickey2.parseSerializedKeypairSignature)(serializedSignature);
+    default:
+      throw new Error("Unsupported signature scheme");
+  }
+}

package/dist/cjs/experimental/cache.d.ts

@@ -0,0 +1,12 @@
+export interface ClientCacheOptions {
+    prefix?: string[];
+    cache?: Map<string, unknown>;
+}
+export declare class ClientCache {
+    #private;
+    constructor({ prefix, cache }?: ClientCacheOptions);
+    read<T>(key: [string, ...string[]], load: () => T | Promise<T>): T | Promise<T>;
+    readSync<T>(key: [string, ...string[]], load: () => T): T;
+    clear(prefix?: string[]): void;
+    scope(prefix: string | string[]): ClientCache;
+}

package/dist/cjs/experimental/client.d.ts

@@ -0,0 +1,12 @@
+import type { Simplify, UnionToIntersection } from "@mysten/utils";
+import { ClientCache } from "./cache.js";
+import type { Experimental_CoreClient } from "./core.js";
+import type { ClientWithExtensions, Experimental_SuiClientTypes, SuiClientRegistration } from "./types.js";
+export declare abstract class Experimental_BaseClient {
+    network: Experimental_SuiClientTypes.Network;
+    cache: ClientCache;
+    base: Experimental_BaseClient;
+    constructor({ network, base, cache, }: Experimental_SuiClientTypes.SuiClientOptions);
+    abstract core: Experimental_CoreClient;
+    $extend<const Registrations extends SuiClientRegistration<this>[]>(...registrations: Registrations): ClientWithExtensions<Simplify<UnionToIntersection<{ [K in keyof Registrations]: Registrations[K] extends SuiClientRegistration<this, infer Name extends string, infer Extension> ? { [K2 in Name]: Extension; } : never; }[number]>>, this>;
+}

package/dist/cjs/experimental/core.d.ts

@@ -0,0 +1,33 @@
+import type { TransactionPlugin } from "../transactions/index.js";
+import { Experimental_BaseClient } from "./client.js";
+import type { ClientWithExtensions, Experimental_SuiClientTypes } from "./types.js";
+export type ClientWithCoreApi = ClientWithExtensions<{
+    core: Experimental_CoreClient;
+}>;
+export interface Experimental_CoreClientOptions extends Experimental_SuiClientTypes.SuiClientOptions {
+    base: Experimental_BaseClient;
+}
+export declare abstract class Experimental_CoreClient extends Experimental_BaseClient implements Experimental_SuiClientTypes.TransportMethods {
+    core: this;
+    constructor(options: Experimental_CoreClientOptions);
+    abstract getObjects(options: Experimental_SuiClientTypes.GetObjectsOptions): Promise<Experimental_SuiClientTypes.GetObjectsResponse>;
+    getObject(options: Experimental_SuiClientTypes.GetObjectOptions): Promise<Experimental_SuiClientTypes.GetObjectResponse>;
+    abstract getCoins(options: Experimental_SuiClientTypes.GetCoinsOptions): Promise<Experimental_SuiClientTypes.GetCoinsResponse>;
+    abstract getOwnedObjects(options: Experimental_SuiClientTypes.GetOwnedObjectsOptions): Promise<Experimental_SuiClientTypes.GetOwnedObjectsResponse>;
+    abstract getBalance(options: Experimental_SuiClientTypes.GetBalanceOptions): Promise<Experimental_SuiClientTypes.GetBalanceResponse>;
+    abstract getAllBalances(options: Experimental_SuiClientTypes.GetAllBalancesOptions): Promise<Experimental_SuiClientTypes.GetAllBalancesResponse>;
+    abstract getTransaction(options: Experimental_SuiClientTypes.GetTransactionOptions): Promise<Experimental_SuiClientTypes.GetTransactionResponse>;
+    abstract executeTransaction(options: Experimental_SuiClientTypes.ExecuteTransactionOptions): Promise<Experimental_SuiClientTypes.ExecuteTransactionResponse>;
+    abstract dryRunTransaction(options: Experimental_SuiClientTypes.DryRunTransactionOptions): Promise<Experimental_SuiClientTypes.DryRunTransactionResponse>;
+    abstract getReferenceGasPrice(options?: Experimental_SuiClientTypes.GetReferenceGasPriceOptions): Promise<Experimental_SuiClientTypes.GetReferenceGasPriceResponse>;
+    abstract getDynamicFields(options: Experimental_SuiClientTypes.GetDynamicFieldsOptions): Promise<Experimental_SuiClientTypes.GetDynamicFieldsResponse>;
+    abstract resolveTransactionPlugin(): TransactionPlugin;
+    abstract getMoveFunction(options: Experimental_SuiClientTypes.GetMoveFunctionOptions): Promise<Experimental_SuiClientTypes.GetMoveFunctionResponse>;
+    getDynamicField(options: Experimental_SuiClientTypes.GetDynamicFieldOptions): Promise<Experimental_SuiClientTypes.GetDynamicFieldResponse>;
+    waitForTransaction({ signal, timeout, ...input }: {
+        /** An optional abort signal that can be used to cancel the wait. */
+        signal?: AbortSignal;
+        /** The amount of time to wait for transaction. Defaults to one minute. */
+        timeout?: number;
+    } & Experimental_SuiClientTypes.GetTransactionOptions): Promise<Experimental_SuiClientTypes.GetTransactionResponse>;
+}

package/dist/cjs/experimental/errors.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectResponseError } from "../client/index.js";
+export declare class SuiClientError extends Error {
+}
+export declare class ObjectError extends SuiClientError {
+    code: string;
+    constructor(code: string, message: string);
+    static fromResponse(response: ObjectResponseError, objectId?: string): ObjectError;
+}

package/dist/cjs/experimental/index.d.ts

@@ -0,0 +1,7 @@
+import { Experimental_BaseClient } from "./client.js";
+import type { ClientWithCoreApi, Experimental_CoreClientOptions } from "./core.js";
+import { Experimental_CoreClient } from "./core.js";
+import type { ClientWithExtensions, Experimental_SuiClientTypes, SuiClientRegistration } from "./types.js";
+export { parseTransactionBcs, parseTransactionEffectsBcs, } from "./transports/utils.js";
+export { Experimental_BaseClient, Experimental_CoreClient, type Experimental_CoreClientOptions, type ClientWithExtensions, type Experimental_SuiClientTypes, type SuiClientRegistration, type ClientWithCoreApi, };
+export { ClientCache, type ClientCacheOptions } from "./cache.js";

package/dist/cjs/experimental/persistent-storage.d.ts

@@ -0,0 +1,134 @@
+/**
+ * A persistent storage module that supports multi-process access with file locking mechanism.
+ * This module ensures safe concurrent read/write operations across multiple processes.
+ */
+export declare class PersistentStorage<T> {
+    private readonly filePath;
+    private readonly lock;
+    /**
+     * Creates a new PersistentStorage instance.
+     * @param filePath Path to the storage file
+     */
+    constructor(filePath: string);
+    /**
+     * Reads the entire storage content.
+     * @returns The parsed storage content
+     */
+    readAll(): Promise<T>;
+    /**
+     * Writes data to the storage.
+     * This operation is atomic and safe for multi-process access.
+     * @param data The data to write
+     */
+    writeAll(data: T): Promise<void>;
+    /**
+     * Updates a specific key in the storage.
+     * This operation is atomic and safe for multi-process access.
+     * @param key The key to update
+     * @param value The new value
+     */
+    set<K extends keyof T>(key: K, value: T[K]): Promise<void>;
+    /**
+     * Gets a specific key from the storage.
+     * @param key The key to get
+     * @returns The value associated with the key
+     */
+    get<K extends keyof T>(key: K): Promise<T[K] | undefined>;
+    /**
+     * Updates the storage using a transaction function.
+     * This operation is atomic and safe for multi-process access.
+     * @param transactionFn A function that takes the current data and returns updated data
+     */
+    transaction(transactionFn: (data: T) => T): Promise<void>;
+    /**
+     * Clears all data from the storage.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * A file-based lock implementation that supports both shared and exclusive locks.
+ * This ensures safe concurrent access across multiple processes using atomic file operations.
+ */
+export declare class Lock {
+    private readonly lockPath;
+    private readonly sharedLockPath;
+    private lockFd;
+    private sharedLockCount;
+    private exclusiveLockCount;
+    constructor(lockPath: string);
+    /**
+     * Acquires a shared lock. Multiple processes can hold a shared lock simultaneously.
+     */
+    acquireShared(): Promise<void>;
+    /**
+     * Acquires an exclusive lock. Only one process can hold an exclusive lock at a time.
+     */
+    acquireExclusive(): Promise<void>;
+    /**
+     * Releases a shared lock.
+     */
+    releaseShared(): Promise<void>;
+    /**
+     * Releases an exclusive lock.
+     */
+    releaseExclusive(): Promise<void>;
+}
+/**
+ * A simple key-value store that supports multi-process access and persistence.
+ * This is a higher-level API built on top of PersistentStorage for easier use.
+ */
+export declare class MultiProcessKVStore<T = any> {
+    private readonly storage;
+    /**
+     * Creates a new MultiProcessKVStore instance.
+     * @param filePath Path to the storage file
+     */
+    constructor(filePath: string);
+    /**
+     * Gets a value by key.
+     * @param key The key to get
+     * @returns The value associated with the key, or undefined if not found
+     */
+    get(key: string): Promise<T | undefined>;
+    /**
+     * Sets a value by key.
+     * @param key The key to set
+     * @param value The value to set
+     */
+    set(key: string, value: T): Promise<void>;
+    /**
+     * Deletes a key-value pair.
+     * @param key The key to delete
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Checks if a key exists.
+     * @param key The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Gets all keys.
+     * @returns An array of all keys
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Gets all values.
+     * @returns An array of all values
+     */
+    values(): Promise<T[]>;
+    /**
+     * Gets all key-value pairs.
+     * @returns An array of all key-value pairs
+     */
+    entries(): Promise<[string, T][]>;
+    /**
+     * Clears all key-value pairs.
+     */
+    clear(): Promise<void>;
+    /**
+     * Gets the number of key-value pairs.
+     * @returns The number of key-value pairs
+     */
+    size(): Promise<number>;
+}

package/dist/cjs/experimental/persistent-storage.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Test file for the persistent-storage module
+ * This demonstrates how to use the PersistentStorage and MultiProcessKVStore classes
+ */
+export {};

package/dist/cjs/experimental/transports/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Experimental_SuiClientTypes } from "../types.js";
+export declare function parseTransactionBcs(bytes: Uint8Array): Experimental_SuiClientTypes.TransactionResponse["transaction"];
+export declare function parseTransactionEffectsBcs(effects: Uint8Array): Experimental_SuiClientTypes.TransactionEffects;

package/dist/cjs/experimental/types.d.ts

@@ -0,0 +1,367 @@
+import type { SerializedTransactionDataV2, TransactionPlugin } from "../transactions/index.js";
+import type { ClientCache } from "./cache.js";
+import type { Experimental_BaseClient } from "./client.js";
+export type SuiClientRegistration<T extends Experimental_BaseClient = Experimental_BaseClient, Name extends string = string, Extension = unknown> = {
+    readonly name: Name;
+    readonly register: (client: T) => Extension;
+};
+export type ClientWithExtensions<T, Base extends Experimental_BaseClient = Experimental_BaseClient> = Base & T;
+export declare namespace Experimental_SuiClientTypes {
+    type Network = "mainnet" | "testnet" | "devnet" | "localnet" | (string & {});
+    interface SuiClientOptions {
+        network: Network;
+        base?: Experimental_BaseClient;
+        cache?: ClientCache;
+    }
+    interface CoreClientMethodOptions {
+        signal?: AbortSignal;
+    }
+    /** Object methods */
+    interface TransportMethods {
+        getObjects: (options: GetObjectsOptions) => Promise<GetObjectsResponse>;
+        getOwnedObjects: (options: GetOwnedObjectsOptions) => Promise<GetOwnedObjectsResponse>;
+        getCoins: (options: GetCoinsOptions) => Promise<GetCoinsResponse>;
+        getDynamicFields: (options: GetDynamicFieldsOptions) => Promise<GetDynamicFieldsResponse>;
+        getDynamicField: (options: GetDynamicFieldOptions) => Promise<GetDynamicFieldResponse>;
+    }
+    interface GetObjectsOptions extends CoreClientMethodOptions {
+        objectIds: string[];
+    }
+    interface GetObjectOptions extends CoreClientMethodOptions {
+        objectId: string;
+    }
+    interface GetOwnedObjectsOptions extends CoreClientMethodOptions {
+        address: string;
+        limit?: number;
+        cursor?: string | null;
+        type?: string;
+    }
+    interface GetCoinsOptions extends CoreClientMethodOptions {
+        address: string;
+        coinType: string;
+        limit?: number;
+        cursor?: string | null;
+    }
+    interface GetDynamicFieldsOptions extends CoreClientMethodOptions {
+        parentId: string;
+        limit?: number;
+        cursor?: string | null;
+    }
+    interface GetDynamicFieldOptions extends CoreClientMethodOptions {
+        parentId: string;
+        name: DynamicFieldName;
+    }
+    interface GetObjectsResponse {
+        objects: (ObjectResponse | Error)[];
+    }
+    interface GetObjectResponse {
+        object: ObjectResponse;
+    }
+    interface GetOwnedObjectsResponse {
+        objects: ObjectResponse[];
+        hasNextPage: boolean;
+        cursor: string | null;
+    }
+    interface GetCoinsResponse {
+        objects: CoinResponse[];
+        hasNextPage: boolean;
+        cursor: string | null;
+    }
+    interface ObjectResponse {
+        id: string;
+        version: string;
+        digest: string;
+        owner: ObjectOwner;
+        type: string;
+        content: PromiseLike<Uint8Array>;
+        previousTransaction: string | null;
+    }
+    interface CoinResponse extends ObjectResponse {
+        balance: string;
+    }
+    interface GetDynamicFieldsResponse {
+        hasNextPage: boolean;
+        cursor: string | null;
+        dynamicFields: {
+            id: string;
+            type: string;
+            name: DynamicFieldName;
+        }[];
+    }
+    interface GetDynamicFieldResponse {
+        dynamicField: {
+            name: DynamicFieldName;
+            value: DynamicFieldValue;
+            id: string;
+            version: string;
+            digest: string;
+            type: string;
+            previousTransaction: string | null;
+        };
+    }
+    interface DynamicFieldName {
+        type: string;
+        bcs: Uint8Array;
+    }
+    interface DynamicFieldValue {
+        type: string;
+        bcs: Uint8Array;
+    }
+    /** Balance methods */
+    interface TransportMethods {
+        getBalance: (options: GetBalanceOptions) => Promise<GetBalanceResponse>;
+        getAllBalances: (options: GetAllBalancesOptions) => Promise<GetAllBalancesResponse>;
+    }
+    interface GetBalanceOptions extends CoreClientMethodOptions {
+        address: string;
+        coinType: string;
+    }
+    interface CoinBalance {
+        coinType: string;
+        balance: string;
+    }
+    interface GetBalanceResponse {
+        balance: CoinBalance;
+    }
+    interface GetAllBalancesOptions extends CoreClientMethodOptions {
+        address: string;
+        limit?: number;
+        cursor?: string | null;
+    }
+    interface GetAllBalancesResponse {
+        balances: CoinBalance[];
+        hasNextPage: boolean;
+        cursor: string | null;
+    }
+    /** Transaction methods */
+    interface TransportMethods {
+        getTransaction: (options: GetTransactionOptions) => Promise<GetTransactionResponse>;
+        executeTransaction: (options: ExecuteTransactionOptions) => Promise<ExecuteTransactionResponse>;
+        dryRunTransaction: (options: DryRunTransactionOptions) => Promise<DryRunTransactionResponse>;
+        resolveTransactionPlugin: () => TransactionPlugin;
+    }
+    interface TransactionResponse {
+        digest: string;
+        signatures: string[];
+        epoch: string | null;
+        effects: TransactionEffects;
+        objectTypes: PromiseLike<Record<string, string>>;
+        transaction: TransactionData;
+        balanceChanges: BalanceChange[];
+    }
+    interface BalanceChange {
+        coinType: string;
+        address: string;
+        amount: string;
+    }
+    interface TransactionData extends SerializedTransactionDataV2 {
+        bcs: Uint8Array;
+    }
+    interface GetTransactionOptions extends CoreClientMethodOptions {
+        digest: string;
+    }
+    interface GetTransactionResponse {
+        transaction: TransactionResponse;
+    }
+    interface ExecuteTransactionOptions extends CoreClientMethodOptions {
+        transaction: Uint8Array;
+        signatures: string[];
+    }
+    interface DryRunTransactionOptions extends CoreClientMethodOptions {
+        transaction: Uint8Array;
+    }
+    interface DryRunTransactionResponse {
+        transaction: TransactionResponse;
+    }
+    interface ExecuteTransactionResponse {
+        transaction: TransactionResponse;
+    }
+    interface GetReferenceGasPriceOptions extends CoreClientMethodOptions {
+    }
+    interface TransportMethods {
+        getReferenceGasPrice?: (options?: GetReferenceGasPriceOptions) => Promise<GetReferenceGasPriceResponse>;
+    }
+    interface GetReferenceGasPriceResponse {
+        referenceGasPrice: string;
+    }
+    /** Move package methods */
+    interface TransportMethods {
+        getMoveFunction: (options: GetMoveFunctionOptions) => Promise<GetMoveFunctionResponse>;
+    }
+    interface GetMovePackageOptions extends CoreClientMethodOptions {
+        packageId: string;
+    }
+    interface GetMovePackageResponse {
+        package: PackageResponse;
+    }
+    interface PackageResponse {
+        storageId: string;
+        originalId: string;
+        version: string;
+        modules: ModuleResponse[];
+    }
+    interface ModuleResponse {
+        name: string;
+        datatypes: DatatypeResponse[];
+        functions: FunctionResponse[];
+    }
+    type DatatypeResponse = {
+        $kind: "struct";
+        typeName: string;
+        definingId: string;
+        moduleName: string;
+        name: string;
+        abilities: Ability[];
+        typeParameters: TypeParameter[];
+        fields: FieldDescriptor[];
+    } | {
+        $kind: "enum";
+        typeName: string;
+        definingId: string;
+        moduleName: string;
+        name: string;
+        abilities: Ability[];
+        typeParameters: TypeParameter[];
+        variants: VariantDescriptor[];
+    };
+    type Ability = "copy" | "drop" | "store" | "key" | "unknown";
+    type DatatypeKind = "struct" | "enum" | "unknown";
+    interface TypeParameter {
+        constraints: Ability[];
+        isPhantom: boolean;
+    }
+    interface FieldDescriptor {
+        name: string;
+        position: number;
+        type: OpenSignatureBody;
+    }
+    interface VariantDescriptor {
+        name: string;
+        position: number;
+        fields: FieldDescriptor[];
+    }
+    interface GetMoveFunctionOptions extends CoreClientMethodOptions {
+        packageId: string;
+        moduleName: string;
+        name: string;
+    }
+    interface GetMoveFunctionResponse {
+        function: FunctionResponse;
+    }
+    interface GetMoveDatatypeOptions extends CoreClientMethodOptions {
+        packageId: string;
+        moduleName: string;
+        name: string;
+    }
+    interface GetMoveDatatypeResponse {
+        datatype: DatatypeResponse;
+    }
+    type Visibility = "public" | "friend" | "private" | "unknown";
+    interface FunctionResponse {
+        packageId: string;
+        moduleName: string;
+        name: string;
+        visibility: Visibility;
+        isEntry: boolean;
+        typeParameters: TypeParameter[];
+        parameters: OpenSignature[];
+        returns: OpenSignature[];
+    }
+    type ReferenceType = "mutable" | "immutable" | "unknown";
+    type OpenSignature = {
+        reference: ReferenceType | null;
+        body: OpenSignatureBody;
+    };
+    type OpenSignatureBody = {
+        $kind: "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "bool" | "address" | "unknown";
+    } | {
+        $kind: "vector";
+        vector: OpenSignatureBody;
+    } | {
+        $kind: "datatype";
+        datatype: {
+            typeName: string;
+            typeParameters: OpenSignatureBody[];
+        };
+    } | {
+        $kind: "typeParameter";
+        index: number;
+    };
+    /** ObjectOwner types */
+    interface AddressOwner {
+        $kind: "AddressOwner";
+        AddressOwner: string;
+    }
+    interface ParentOwner {
+        $kind: "ObjectOwner";
+        ObjectOwner: string;
+    }
+    interface SharedOwner {
+        $kind: "Shared";
+        Shared: {
+            initialSharedVersion: string;
+        };
+    }
+    interface ImmutableOwner {
+        $kind: "Immutable";
+        Immutable: true;
+    }
+    interface ConsensusAddressOwner {
+        $kind: "ConsensusAddressOwner";
+        ConsensusAddressOwner: {
+            owner: string;
+            startVersion: string;
+        };
+    }
+    interface UnknownOwner {
+        $kind: "Unknown";
+    }
+    type ObjectOwner = AddressOwner | ParentOwner | SharedOwner | ImmutableOwner | ConsensusAddressOwner | UnknownOwner;
+    /** Effects */
+    interface TransactionEffects {
+        bcs: Uint8Array | null;
+        digest: string;
+        version: number;
+        status: ExecutionStatus;
+        gasUsed: GasCostSummary;
+        transactionDigest: string;
+        gasObject: ChangedObject | null;
+        eventsDigest: string | null;
+        dependencies: string[];
+        lamportVersion: string | null;
+        changedObjects: ChangedObject[];
+        unchangedConsensusObjects: UnchangedConsensusObject[];
+        auxiliaryDataDigest: string | null;
+    }
+    interface ChangedObject {
+        id: string;
+        inputState: "Unknown" | "DoesNotExist" | "Exists";
+        inputVersion: string | null;
+        inputDigest: string | null;
+        inputOwner: ObjectOwner | null;
+        outputState: "Unknown" | "DoesNotExist" | "ObjectWrite" | "PackageWrite";
+        outputVersion: string | null;
+        outputDigest: string | null;
+        outputOwner: ObjectOwner | null;
+        idOperation: "Unknown" | "None" | "Created" | "Deleted";
+    }
+    interface GasCostSummary {
+        computationCost: string;
+        storageCost: string;
+        storageRebate: string;
+        nonRefundableStorageFee: string;
+    }
+    type ExecutionStatus = {
+        success: true;
+        error: null;
+    } | {
+        success: false;
+        error: string;
+    };
+    interface UnchangedConsensusObject {
+        kind: "Unknown" | "ReadOnlyRoot" | "MutateConsensusStreamEnded" | "ReadConsensusStreamEnded" | "Cancelled" | "PerEpochConfig";
+        objectId: string;
+        version: string | null;
+        digest: string | null;
+    }
+}