@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/dist/_generated/zing_studio/deps/walrus/events.js

@@ -0,0 +1,122 @@
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/walrus::events";
+export const BlobRegistered = new MoveStruct({
+    name: `${$moduleName}::BlobRegistered`,
+    fields: {
+        epoch: bcs.u32(),
+        blob_id: bcs.u256(),
+        size: bcs.u64(),
+        encoding_type: bcs.u8(),
+        end_epoch: bcs.u32(),
+        deletable: bcs.bool(),
+        object_id: bcs.Address,
+    },
+});
+export const BlobCertified = new MoveStruct({
+    name: `${$moduleName}::BlobCertified`,
+    fields: {
+        epoch: bcs.u32(),
+        blob_id: bcs.u256(),
+        end_epoch: bcs.u32(),
+        deletable: bcs.bool(),
+        object_id: bcs.Address,
+        is_extension: bcs.bool(),
+    },
+});
+export const BlobDeleted = new MoveStruct({
+    name: `${$moduleName}::BlobDeleted`,
+    fields: {
+        epoch: bcs.u32(),
+        blob_id: bcs.u256(),
+        end_epoch: bcs.u32(),
+        object_id: bcs.Address,
+        was_certified: bcs.bool(),
+    },
+});
+export const InvalidBlobID = new MoveStruct({
+    name: `${$moduleName}::InvalidBlobID`,
+    fields: {
+        epoch: bcs.u32(),
+        blob_id: bcs.u256(),
+    },
+});
+export const EpochChangeStart = new MoveStruct({
+    name: `${$moduleName}::EpochChangeStart`,
+    fields: {
+        epoch: bcs.u32(),
+    },
+});
+export const EpochChangeDone = new MoveStruct({
+    name: `${$moduleName}::EpochChangeDone`,
+    fields: {
+        epoch: bcs.u32(),
+    },
+});
+export const ShardsReceived = new MoveStruct({
+    name: `${$moduleName}::ShardsReceived`,
+    fields: {
+        epoch: bcs.u32(),
+        shards: bcs.vector(bcs.u16()),
+    },
+});
+export const EpochParametersSelected = new MoveStruct({
+    name: `${$moduleName}::EpochParametersSelected`,
+    fields: {
+        next_epoch: bcs.u32(),
+    },
+});
+export const ShardRecoveryStart = new MoveStruct({
+    name: `${$moduleName}::ShardRecoveryStart`,
+    fields: {
+        epoch: bcs.u32(),
+        shards: bcs.vector(bcs.u16()),
+    },
+});
+export const ContractUpgraded = new MoveStruct({
+    name: `${$moduleName}::ContractUpgraded`,
+    fields: {
+        epoch: bcs.u32(),
+        package_id: bcs.Address,
+        version: bcs.u64(),
+    },
+});
+export const RegisterDenyListUpdate = new MoveStruct({
+    name: `${$moduleName}::RegisterDenyListUpdate`,
+    fields: {
+        epoch: bcs.u32(),
+        root: bcs.u256(),
+        sequence_number: bcs.u64(),
+        node_id: bcs.Address,
+    },
+});
+export const DenyListUpdate = new MoveStruct({
+    name: `${$moduleName}::DenyListUpdate`,
+    fields: {
+        epoch: bcs.u32(),
+        root: bcs.u256(),
+        sequence_number: bcs.u64(),
+        node_id: bcs.Address,
+    },
+});
+export const DenyListBlobDeleted = new MoveStruct({
+    name: `${$moduleName}::DenyListBlobDeleted`,
+    fields: {
+        epoch: bcs.u32(),
+        blob_id: bcs.u256(),
+    },
+});
+export const ContractUpgradeProposed = new MoveStruct({
+    name: `${$moduleName}::ContractUpgradeProposed`,
+    fields: {
+        epoch: bcs.u32(),
+        package_digest: bcs.vector(bcs.u8()),
+    },
+});
+export const ContractUpgradeQuorumReached = new MoveStruct({
+    name: `${$moduleName}::ContractUpgradeQuorumReached`,
+    fields: {
+        epoch: bcs.u32(),
+        package_digest: bcs.vector(bcs.u8()),
+    },
+});

package/dist/_generated/zing_studio/deps/walrus/metadata.d.ts

@@ -0,0 +1,71 @@
+import { MoveStruct } from "../../../utils/index.js";
+import type { RawTransactionArgument } from "../../../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const Metadata: MoveStruct<{
+    metadata: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: string;
+            value: string;
+        }[], Iterable<{
+            key: string;
+            value: string;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, string>">;
+}, "@local-pkg/walrus::metadata::Metadata">;
+export interface NewOptions {
+    package?: string;
+    arguments?: [];
+}
+/** Creates a new instance of Metadata. */
+export declare function _new(options?: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InsertOrUpdateArguments {
+    self: RawTransactionArgument<string>;
+    key: RawTransactionArgument<string>;
+    value: RawTransactionArgument<string>;
+}
+export interface InsertOrUpdateOptions {
+    package?: string;
+    arguments: InsertOrUpdateArguments | [
+        self: RawTransactionArgument<string>,
+        key: RawTransactionArgument<string>,
+        value: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Inserts a key-value pair into the metadata.
+ *
+ * If the key is already present, the value is updated.
+ */
+export declare function insertOrUpdate(options: InsertOrUpdateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveArguments {
+    self: RawTransactionArgument<string>;
+    key: RawTransactionArgument<string>;
+}
+export interface RemoveOptions {
+    package?: string;
+    arguments: RemoveArguments | [
+        self: RawTransactionArgument<string>,
+        key: RawTransactionArgument<string>
+    ];
+}
+/** Removes the metadata associated with the given key. */
+export declare function remove(options: RemoveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveIfExistsArguments {
+    self: RawTransactionArgument<string>;
+    key: RawTransactionArgument<string>;
+}
+export interface RemoveIfExistsOptions {
+    package?: string;
+    arguments: RemoveIfExistsArguments | [
+        self: RawTransactionArgument<string>,
+        key: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Removes the metadata associated with the given key, if it exists.
+ *
+ * Optionally returns the previous value associated with the key.
+ */
+export declare function removeIfExists(options: RemoveIfExistsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/deps/walrus/metadata.js

@@ -0,0 +1,73 @@
+import { MoveStruct, normalizeMoveArguments } from "../../../utils/index.js";
+import * as vec_map from "../sui/vec_map.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/walrus::metadata";
+export const Metadata = new MoveStruct({
+    name: `${$moduleName}::Metadata`,
+    fields: {
+        metadata: vec_map.VecMap(bcs.string(), bcs.string()),
+    },
+});
+/** Creates a new instance of Metadata. */
+export function _new(options = {}) {
+    const packageAddress = options.package ?? "@local-pkg/walrus";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "metadata",
+        function: "new",
+    });
+}
+/**
+ * Inserts a key-value pair into the metadata.
+ *
+ * If the key is already present, the value is updated.
+ */
+export function insertOrUpdate(options) {
+    const packageAddress = options.package ?? "@local-pkg/walrus";
+    const argumentsTypes = [
+        `${packageAddress}::metadata::Metadata`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+    ];
+    const parameterNames = ["self", "key", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "metadata",
+        function: "insert_or_update",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Removes the metadata associated with the given key. */
+export function remove(options) {
+    const packageAddress = options.package ?? "@local-pkg/walrus";
+    const argumentsTypes = [
+        `${packageAddress}::metadata::Metadata`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+    ];
+    const parameterNames = ["self", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "metadata",
+        function: "remove",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Removes the metadata associated with the given key, if it exists.
+ *
+ * Optionally returns the previous value associated with the key.
+ */
+export function removeIfExists(options) {
+    const packageAddress = options.package ?? "@local-pkg/walrus";
+    const argumentsTypes = [
+        `${packageAddress}::metadata::Metadata`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+    ];
+    const parameterNames = ["self", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "metadata",
+        function: "remove_if_exists",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/_generated/zing_studio/deps/walrus/storage_resource.d.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../../../utils/index.js";
+export declare const Storage: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    start_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    end_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    storage_size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "walrus::storage_resource::Storage">;

package/{src/_generated/zing_studio/deps/walrus/storage_resource.ts → dist/_generated/zing_studio/deps/walrus/storage_resource.js}

@@ -4,14 +4,13 @@
 import { MoveStruct } from "../../../utils/index.js";
 import * as object from "../sui/object.js";
 import { bcs } from "@mysten/sui/bcs";
-
 const $moduleName = "walrus::storage_resource";
 export const Storage = new MoveStruct({
-  name: `${$moduleName}::Storage`,
-  fields: {
-    id: object.UID,
-    start_epoch: bcs.u32(),
-    end_epoch: bcs.u32(),
-    storage_size: bcs.u64(),
-  },
+    name: `${$moduleName}::Storage`,
+    fields: {
+        id: object.UID,
+        start_epoch: bcs.u32(),
+        end_epoch: bcs.u32(),
+        storage_size: bcs.u64(),
+    },
 });

package/dist/_generated/zing_studio/deps/zing_framework/derived_object_bag.d.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../../../utils/index.js";
+export declare const DerivedObjectBag: MoveStruct<{
+    /** the ID of this bag */
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    /** the number of key-value pairs in the bag */
+    size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "zing_framework::derived_object_bag::DerivedObjectBag">;

package/{src/_generated/zing_studio/deps/zing_framework/derived_object_bag.ts → dist/_generated/zing_studio/deps/zing_framework/derived_object_bag.js}

@@ -4,14 +4,13 @@
 import { MoveStruct } from "../../../utils/index.js";
 import * as object from "../sui/object.js";
 import { bcs } from "@mysten/sui/bcs";
-
 const $moduleName = "zing_framework::derived_object_bag";
 export const DerivedObjectBag = new MoveStruct({
-  name: `${$moduleName}::DerivedObjectBag`,
-  fields: {
-    /** the ID of this bag */
-    id: object.UID,
-    /** the number of key-value pairs in the bag */
-    size: bcs.u64(),
-  },
+    name: `${$moduleName}::DerivedObjectBag`,
+    fields: {
+        /** the ID of this bag */
+        id: object.UID,
+        /** the number of key-value pairs in the bag */
+        size: bcs.u64(),
+    },
 });

package/dist/_generated/zing_studio/deps/zing_framework/derived_table.d.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../../../utils/index.js";
+export declare const DerivedTable: MoveStruct<{
+    /** the ID of this table */
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    /** the number of key-value pairs in the table */
+    size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "zing_framework::derived_table::DerivedTable">;

package/{src/_generated/zing_studio/deps/zing_framework/derived_table.ts → dist/_generated/zing_studio/deps/zing_framework/derived_table.js}

@@ -4,14 +4,13 @@
 import { MoveStruct } from "../../../utils/index.js";
 import * as object from "../sui/object.js";
 import { bcs } from "@mysten/sui/bcs";
-
 const $moduleName = "zing_framework::derived_table";
 export const DerivedTable = new MoveStruct({
-  name: `${$moduleName}::DerivedTable`,
-  fields: {
-    /** the ID of this table */
-    id: object.UID,
-    /** the number of key-value pairs in the table */
-    size: bcs.u64(),
-  },
+    name: `${$moduleName}::DerivedTable`,
+    fields: {
+        /** the ID of this table */
+        id: object.UID,
+        /** the number of key-value pairs in the table */
+        size: bcs.u64(),
+    },
 });

package/dist/_generated/zing_studio/donation.d.ts

@@ -0,0 +1,24 @@
+import { MoveStruct } from "../utils/index.js";
+export declare const Donation: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    donations: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table">;
+    accumulated_donations: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table">;
+    balances: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::bag::Bag">;
+}, "@local-pkg/zing_studio::donation::Donation">;

package/{src/_generated/zing_studio/donation.ts → dist/_generated/zing_studio/donation.js}

@@ -5,14 +5,13 @@ import * as bag from "./deps/sui/bag.js";
 import * as object from "./deps/sui/object.js";
 import * as table from "./deps/sui/table.js";
 import { MoveStruct } from "../utils/index.js";
-
 const $moduleName = "@local-pkg/zing_studio::donation";
 export const Donation = new MoveStruct({
-  name: `${$moduleName}::Donation`,
-  fields: {
-    id: object.UID,
-    donations: table.Table,
-    accumulated_donations: table.Table,
-    balances: bag.Bag,
-  },
+    name: `${$moduleName}::Donation`,
+    fields: {
+        id: object.UID,
+        donations: table.Table,
+        accumulated_donations: table.Table,
+        balances: bag.Bag,
+    },
 });

package/dist/_generated/zing_studio/enclave.d.ts

@@ -0,0 +1,187 @@
+import { MoveTuple, MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { BcsType } from "@mysten/sui/bcs";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const Pcrs: MoveTuple<BcsType<number[], Iterable<number> & {
+    length: number;
+}, string>[], "@local-pkg/zing_studio::enclave::Pcrs">;
+export declare const EnclaveConfig: MoveStruct<{
+    id: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    name: BcsType<string, string, "string">;
+    pcrs: MoveTuple<BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>[], "@local-pkg/zing_studio::enclave::Pcrs">;
+    version: BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::enclave::EnclaveConfig">;
+export declare const Enclave: MoveStruct<{
+    id: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    pk: BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    config_version: BcsType<string, string | number | bigint, "u64">;
+    owner: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@local-pkg/zing_studio::enclave::Enclave">;
+export declare function IntentMessage<T extends BcsType<any>>(...typeParameters: [T]): MoveStruct<{
+    intent: BcsType<number, number, "u8">;
+    timestamp_ms: BcsType<string, string | number | bigint, "u64">;
+    payload: T;
+}, `@local-pkg/zing_studio::enclave::IntentMessage<${T["name"]}>`>;
+export interface CreateEnclaveConfigArguments {
+    Cap: RawTransactionArgument<string>;
+    name: RawTransactionArgument<string>;
+    pcr0: RawTransactionArgument<number[]>;
+    pcr1: RawTransactionArgument<number[]>;
+    pcr2: RawTransactionArgument<number[]>;
+}
+export interface CreateEnclaveConfigOptions {
+    package?: string;
+    arguments: CreateEnclaveConfigArguments | [
+        Cap: RawTransactionArgument<string>,
+        name: RawTransactionArgument<string>,
+        pcr0: RawTransactionArgument<number[]>,
+        pcr1: RawTransactionArgument<number[]>,
+        pcr2: RawTransactionArgument<number[]>
+    ];
+}
+export declare function createEnclaveConfig(options: CreateEnclaveConfigOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegisterEnclaveArguments {
+    enclaveConfig: RawTransactionArgument<string>;
+    document: RawTransactionArgument<string>;
+}
+export interface RegisterEnclaveOptions {
+    package?: string;
+    arguments: RegisterEnclaveArguments | [
+        enclaveConfig: RawTransactionArgument<string>,
+        document: RawTransactionArgument<string>
+    ];
+}
+export declare function registerEnclave(options: RegisterEnclaveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifySignatureArguments<P extends BcsType<any>> {
+    enclave: RawTransactionArgument<string>;
+    intentScope: RawTransactionArgument<number>;
+    timestampMs: RawTransactionArgument<number | bigint>;
+    payload: RawTransactionArgument<P>;
+    signature: RawTransactionArgument<number[]>;
+}
+export interface VerifySignatureOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: VerifySignatureArguments<P> | [
+        enclave: RawTransactionArgument<string>,
+        intentScope: RawTransactionArgument<number>,
+        timestampMs: RawTransactionArgument<number | bigint>,
+        payload: RawTransactionArgument<P>,
+        signature: RawTransactionArgument<number[]>
+    ];
+    typeArguments: [string];
+}
+export declare function verifySignature<P extends BcsType<any>>(options: VerifySignatureOptions<P>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdatePcrsWithDocumentArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    document: RawTransactionArgument<string>;
+}
+export interface UpdatePcrsWithDocumentOptions {
+    package?: string;
+    arguments: UpdatePcrsWithDocumentArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        document: RawTransactionArgument<string>
+    ];
+}
+export declare function updatePcrsWithDocument(options: UpdatePcrsWithDocumentOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdatePcrsArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    pcr0: RawTransactionArgument<number[]>;
+    pcr1: RawTransactionArgument<number[]>;
+    pcr2: RawTransactionArgument<number[]>;
+}
+export interface UpdatePcrsOptions {
+    package?: string;
+    arguments: UpdatePcrsArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        pcr0: RawTransactionArgument<number[]>,
+        pcr1: RawTransactionArgument<number[]>,
+        pcr2: RawTransactionArgument<number[]>
+    ];
+}
+export declare function updatePcrs(options: UpdatePcrsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateNameArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    name: RawTransactionArgument<string>;
+}
+export interface UpdateNameOptions {
+    package?: string;
+    arguments: UpdateNameArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        name: RawTransactionArgument<string>
+    ];
+}
+export declare function updateName(options: UpdateNameOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface Pcr0Arguments {
+    config: RawTransactionArgument<string>;
+}
+export interface Pcr0Options {
+    package?: string;
+    arguments: Pcr0Arguments | [config: RawTransactionArgument<string>];
+}
+export declare function pcr0(options: Pcr0Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface Pcr1Arguments {
+    config: RawTransactionArgument<string>;
+}
+export interface Pcr1Options {
+    package?: string;
+    arguments: Pcr1Arguments | [config: RawTransactionArgument<string>];
+}
+export declare function pcr1(options: Pcr1Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface Pcr2Arguments {
+    config: RawTransactionArgument<string>;
+}
+export interface Pcr2Options {
+    package?: string;
+    arguments: Pcr2Arguments | [config: RawTransactionArgument<string>];
+}
+export declare function pcr2(options: Pcr2Options): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PkArguments {
+    enclave: RawTransactionArgument<string>;
+}
+export interface PkOptions {
+    package?: string;
+    arguments: PkArguments | [enclave: RawTransactionArgument<string>];
+}
+export declare function pk(options: PkOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DestroyOldEnclaveArguments {
+    e: RawTransactionArgument<string>;
+    config: RawTransactionArgument<string>;
+}
+export interface DestroyOldEnclaveOptions {
+    package?: string;
+    arguments: DestroyOldEnclaveArguments | [
+        e: RawTransactionArgument<string>,
+        config: RawTransactionArgument<string>
+    ];
+}
+export declare function destroyOldEnclave(options: DestroyOldEnclaveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DeployOldEnclaveByOwnerArguments {
+    e: RawTransactionArgument<string>;
+}
+export interface DeployOldEnclaveByOwnerOptions {
+    package?: string;
+    arguments: DeployOldEnclaveByOwnerArguments | [e: RawTransactionArgument<string>];
+}
+export declare function deployOldEnclaveByOwner(options: DeployOldEnclaveByOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PkToAddressArguments {
+    pk: RawTransactionArgument<number[]>;
+}
+export interface PkToAddressOptions {
+    package?: string;
+    arguments: PkToAddressArguments | [pk: RawTransactionArgument<number[]>];
+}
+export declare function pkToAddress(options: PkToAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;