@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/_generated/zing_studio/enclave.js

@@ -0,0 +1,231 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as object from "./deps/sui/object.js";
+import { MoveTuple, MoveStruct, normalizeMoveArguments, } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_studio::enclave";
+export const Pcrs = new MoveTuple({
+    name: `${$moduleName}::Pcrs`,
+    fields: [bcs.vector(bcs.u8()), bcs.vector(bcs.u8()), bcs.vector(bcs.u8())],
+});
+export const EnclaveConfig = new MoveStruct({
+    name: `${$moduleName}::EnclaveConfig`,
+    fields: {
+        id: object.UID,
+        name: bcs.string(),
+        pcrs: Pcrs,
+        version: bcs.u64(),
+    },
+});
+export const Enclave = new MoveStruct({
+    name: `${$moduleName}::Enclave`,
+    fields: {
+        id: object.UID,
+        pk: bcs.vector(bcs.u8()),
+        config_version: bcs.u64(),
+        owner: bcs.Address,
+    },
+});
+export function IntentMessage(...typeParameters) {
+    return new MoveStruct({
+        name: `${$moduleName}::IntentMessage<${typeParameters[0].name}>`,
+        fields: {
+            intent: bcs.u8(),
+            timestamp_ms: bcs.u64(),
+            payload: typeParameters[0],
+        },
+    });
+}
+export function createEnclaveConfig(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::admin::AdminCap`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+        "vector<u8>",
+        "vector<u8>",
+        "vector<u8>",
+    ];
+    const parameterNames = ["Cap", "name", "pcr0", "pcr1", "pcr2"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "create_enclave_config",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function registerEnclave(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::EnclaveConfig`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::nitro_attestation::NitroAttestationDocument",
+    ];
+    const parameterNames = ["enclaveConfig", "document"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "register_enclave",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function verifySignature(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::Enclave`,
+        "u8",
+        "u64",
+        `${options.typeArguments[0]}`,
+        "vector<u8>",
+    ];
+    const parameterNames = [
+        "enclave",
+        "intentScope",
+        "timestampMs",
+        "payload",
+        "signature",
+    ];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "verify_signature",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function updatePcrsWithDocument(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::EnclaveConfig`,
+        `${packageAddress}::admin::AdminCap`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::nitro_attestation::NitroAttestationDocument",
+    ];
+    const parameterNames = ["config", "Cap", "document"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "update_pcrs_with_document",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function updatePcrs(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::EnclaveConfig`,
+        `${packageAddress}::admin::AdminCap`,
+        "vector<u8>",
+        "vector<u8>",
+        "vector<u8>",
+    ];
+    const parameterNames = ["config", "Cap", "pcr0", "pcr1", "pcr2"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "update_pcrs",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function updateName(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::EnclaveConfig`,
+        `${packageAddress}::admin::AdminCap`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+    ];
+    const parameterNames = ["config", "Cap", "name"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "update_name",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function pcr0(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::EnclaveConfig`,
+    ];
+    const parameterNames = ["config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "pcr0",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function pcr1(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::EnclaveConfig`,
+    ];
+    const parameterNames = ["config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "pcr1",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function pcr2(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::EnclaveConfig`,
+    ];
+    const parameterNames = ["config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "pcr2",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function pk(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::Enclave`,
+    ];
+    const parameterNames = ["enclave"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "pk",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function destroyOldEnclave(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::Enclave`,
+        `${packageAddress}::enclave::EnclaveConfig`,
+    ];
+    const parameterNames = ["e", "config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "destroy_old_enclave",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function deployOldEnclaveByOwner(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::enclave::Enclave`,
+    ];
+    const parameterNames = ["e"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "deploy_old_enclave_by_owner",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function pkToAddress(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = ["vector<u8>"];
+    const parameterNames = ["pk"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "enclave",
+        function: "pk_to_address",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

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

@@ -0,0 +1,148 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const PCREntry: MoveStruct<{
+    index: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    value: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@local-pkg/zing_studio::nitro_attestation::PCREntry">;
+export declare const NitroAttestationDocument: MoveStruct<{
+    /** Issuing Nitro hypervisor module ID. */
+    module_id: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    /** UTC time when document was created, in milliseconds since UNIX epoch. */
+    timestamp: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** The digest function used for calculating the register values. */
+    digest: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    /**
+     * A list of PCREntry containing the index and the PCR bytes.
+     * <https://docs.aws.amazon.com/enclaves/latest/user/set-up-attestation.html#where>.
+     */
+    pcrs: import("@mysten/sui/bcs").BcsType<{
+        index: number;
+        value: number[];
+    }[], Iterable<{
+        index: number;
+        value: Iterable<number> & {
+            length: number;
+        };
+    }> & {
+        length: number;
+    }, string>;
+    /**
+     * An optional DER-encoded key the attestation, consumer can use to encrypt data
+     * with.
+     */
+    public_key: import("@mysten/sui/bcs").BcsType<number[] | null, (Iterable<number> & {
+        length: number;
+    }) | null | undefined, "Option<vector<u8>>">;
+    /** Additional signed user data, defined by protocol. */
+    user_data: import("@mysten/sui/bcs").BcsType<number[] | null, (Iterable<number> & {
+        length: number;
+    }) | null | undefined, "Option<vector<u8>>">;
+    /**
+     * An optional cryptographic nonce provided by the attestation consumer as a proof
+     * of authenticity.
+     */
+    nonce: import("@mysten/sui/bcs").BcsType<number[] | null, (Iterable<number> & {
+        length: number;
+    }) | null | undefined, "Option<vector<u8>>">;
+}, "@local-pkg/zing_studio::nitro_attestation::NitroAttestationDocument">;
+export interface LoadNitroAttestationArguments {
+    attestation: RawTransactionArgument<number[]>;
+}
+export interface LoadNitroAttestationOptions {
+    package?: string;
+    arguments: LoadNitroAttestationArguments | [attestation: RawTransactionArgument<number[]>];
+}
+/**
+ * @param attestation: attesttaion documents bytes data. @param clock: the clock
+ * object.
+ *
+ * Returns the parsed NitroAttestationDocument after verifying the attestation, may
+ * abort with errors described above.
+ */
+export declare function loadNitroAttestation(options: LoadNitroAttestationOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ModuleIdArguments {
+    attestation: RawTransactionArgument<string>;
+}
+export interface ModuleIdOptions {
+    package?: string;
+    arguments: ModuleIdArguments | [attestation: RawTransactionArgument<string>];
+}
+export declare function moduleId(options: ModuleIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TimestampArguments {
+    attestation: RawTransactionArgument<string>;
+}
+export interface TimestampOptions {
+    package?: string;
+    arguments: TimestampArguments | [attestation: RawTransactionArgument<string>];
+}
+export declare function timestamp(options: TimestampOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DigestArguments {
+    attestation: RawTransactionArgument<string>;
+}
+export interface DigestOptions {
+    package?: string;
+    arguments: DigestArguments | [attestation: RawTransactionArgument<string>];
+}
+export declare function digest(options: DigestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PcrsArguments {
+    attestation: RawTransactionArgument<string>;
+}
+export interface PcrsOptions {
+    package?: string;
+    arguments: PcrsArguments | [attestation: RawTransactionArgument<string>];
+}
+/**
+ * Returns a list of mapping PCREntry containg the index and the PCR bytes.
+ * Currently AWS supports PCR0, PCR1, PCR2, PCR3, PCR4, PCR8.
+ */
+export declare function pcrs(options: PcrsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PublicKeyArguments {
+    attestation: RawTransactionArgument<string>;
+}
+export interface PublicKeyOptions {
+    package?: string;
+    arguments: PublicKeyArguments | [attestation: RawTransactionArgument<string>];
+}
+export declare function publicKey(options: PublicKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UserDataArguments {
+    attestation: RawTransactionArgument<string>;
+}
+export interface UserDataOptions {
+    package?: string;
+    arguments: UserDataArguments | [attestation: RawTransactionArgument<string>];
+}
+export declare function userData(options: UserDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NonceArguments {
+    attestation: RawTransactionArgument<string>;
+}
+export interface NonceOptions {
+    package?: string;
+    arguments: NonceArguments | [attestation: RawTransactionArgument<string>];
+}
+export declare function nonce(options: NonceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IndexArguments {
+    entry: RawTransactionArgument<string>;
+}
+export interface IndexOptions {
+    package?: string;
+    arguments: IndexArguments | [entry: RawTransactionArgument<string>];
+}
+export declare function index(options: IndexOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ValueArguments {
+    entry: RawTransactionArgument<string>;
+}
+export interface ValueOptions {
+    package?: string;
+    arguments: ValueArguments | [entry: RawTransactionArgument<string>];
+}
+export declare function value(options: ValueOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/nitro_attestation.js

@@ -0,0 +1,183 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_studio::nitro_attestation";
+export const PCREntry = new MoveStruct({
+    name: `${$moduleName}::PCREntry`,
+    fields: {
+        index: bcs.u8(),
+        value: bcs.vector(bcs.u8()),
+    },
+});
+export const NitroAttestationDocument = new MoveStruct({
+    name: `${$moduleName}::NitroAttestationDocument`,
+    fields: {
+        /** Issuing Nitro hypervisor module ID. */
+        module_id: bcs.vector(bcs.u8()),
+        /** UTC time when document was created, in milliseconds since UNIX epoch. */
+        timestamp: bcs.u64(),
+        /** The digest function used for calculating the register values. */
+        digest: bcs.vector(bcs.u8()),
+        /**
+         * A list of PCREntry containing the index and the PCR bytes.
+         * <https://docs.aws.amazon.com/enclaves/latest/user/set-up-attestation.html#where>.
+         */
+        pcrs: bcs.vector(PCREntry),
+        /**
+         * An optional DER-encoded key the attestation, consumer can use to encrypt data
+         * with.
+         */
+        public_key: bcs.option(bcs.vector(bcs.u8())),
+        /** Additional signed user data, defined by protocol. */
+        user_data: bcs.option(bcs.vector(bcs.u8())),
+        /**
+         * An optional cryptographic nonce provided by the attestation consumer as a proof
+         * of authenticity.
+         */
+        nonce: bcs.option(bcs.vector(bcs.u8())),
+    },
+});
+/**
+ * @param attestation: attesttaion documents bytes data. @param clock: the clock
+ * object.
+ *
+ * Returns the parsed NitroAttestationDocument after verifying the attestation, may
+ * abort with errors described above.
+ */
+export function loadNitroAttestation(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        "vector<u8>",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "load_nitro_attestation",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function moduleId(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::NitroAttestationDocument`,
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "module_id",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function timestamp(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::NitroAttestationDocument`,
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "timestamp",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function digest(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::NitroAttestationDocument`,
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "digest",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns a list of mapping PCREntry containg the index and the PCR bytes.
+ * Currently AWS supports PCR0, PCR1, PCR2, PCR3, PCR4, PCR8.
+ */
+export function pcrs(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::NitroAttestationDocument`,
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "pcrs",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function publicKey(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::NitroAttestationDocument`,
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "public_key",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function userData(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::NitroAttestationDocument`,
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "user_data",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function nonce(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::NitroAttestationDocument`,
+    ];
+    const parameterNames = ["attestation"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "nonce",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function index(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::PCREntry`,
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "index",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function value(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::nitro_attestation::PCREntry`,
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "nitro_attestation",
+        function: "value",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}