@zing-protocol/zing-sdk 0.0.1

package/src/_generated/zing_identity/config.ts

@@ -0,0 +1,191 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as type_name from "./deps/std/type_name.js";
+import * as object from "./deps/sui/object.js";
+import * as vec_set from "./deps/sui/vec_set.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+
+const $moduleName = "@local-pkg/zing_identity::config";
+export const Config = new MoveStruct({
+  name: `${$moduleName}::Config`,
+  fields: {
+    id: object.UID,
+    registry: vec_set.VecSet(type_name.TypeName),
+    versions: vec_set.VecSet(bcs.u64()),
+    base_read_fee: bcs.u64(),
+  },
+});
+export interface PackageVersionOptions {
+  package?: string;
+  arguments?: [];
+}
+export function packageVersion(options: PackageVersionOptions = {}) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "config",
+      function: "package_version",
+    });
+}
+export interface BaseReadFeeArguments {
+  self: RawTransactionArgument<string>;
+}
+export interface BaseReadFeeOptions {
+  package?: string;
+  arguments: BaseReadFeeArguments | [self: RawTransactionArgument<string>];
+}
+export function baseReadFee(options: BaseReadFeeOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = [
+    `${packageAddress}::config::Config`,
+  ] satisfies string[];
+  const parameterNames = ["self"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "config",
+      function: "base_read_fee",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface AddVersionArguments {
+  self: RawTransactionArgument<string>;
+  Cap: RawTransactionArgument<string>;
+  version: RawTransactionArgument<number | bigint>;
+}
+export interface AddVersionOptions {
+  package?: string;
+  arguments:
+    | AddVersionArguments
+    | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        version: RawTransactionArgument<number | bigint>,
+      ];
+}
+export function addVersion(options: AddVersionOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = [
+    `${packageAddress}::config::Config`,
+    `${packageAddress}::admin::AdminCap`,
+    "u64",
+  ] satisfies string[];
+  const parameterNames = ["self", "Cap", "version"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "config",
+      function: "add_version",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface RemoveVersionArguments {
+  self: RawTransactionArgument<string>;
+  Cap: RawTransactionArgument<string>;
+  version: RawTransactionArgument<number | bigint>;
+}
+export interface RemoveVersionOptions {
+  package?: string;
+  arguments:
+    | RemoveVersionArguments
+    | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        version: RawTransactionArgument<number | bigint>,
+      ];
+}
+export function removeVersion(options: RemoveVersionOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = [
+    `${packageAddress}::config::Config`,
+    `${packageAddress}::admin::AdminCap`,
+    "u64",
+  ] satisfies string[];
+  const parameterNames = ["self", "Cap", "version"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "config",
+      function: "remove_version",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface UpdateReadFeeArguments {
+  self: RawTransactionArgument<string>;
+  Cap: RawTransactionArgument<string>;
+  fee: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateReadFeeOptions {
+  package?: string;
+  arguments:
+    | UpdateReadFeeArguments
+    | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        fee: RawTransactionArgument<number | bigint>,
+      ];
+}
+export function updateReadFee(options: UpdateReadFeeOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = [
+    `${packageAddress}::config::Config`,
+    `${packageAddress}::admin::AdminCap`,
+    "u64",
+  ] satisfies string[];
+  const parameterNames = ["self", "Cap", "fee"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "config",
+      function: "update_read_fee",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface DerivedObjectKeyArguments {
+  name: RawTransactionArgument<string>;
+}
+export interface DerivedObjectKeyOptions {
+  package?: string;
+  arguments: DerivedObjectKeyArguments | [name: RawTransactionArgument<string>];
+  typeArguments: [string];
+}
+export function derivedObjectKey(options: DerivedObjectKeyOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String",
+  ] satisfies string[];
+  const parameterNames = ["name"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "config",
+      function: "derived_object_key",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}

package/src/_generated/zing_identity/deps/std/type_name.ts

@@ -0,0 +1,25 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Functionality for converting Move types into values. Use with care! */
+
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "std::type_name";
+export const TypeName = new MoveStruct({
+  name: `${$moduleName}::TypeName`,
+  fields: {
+    /**
+     * String representation of the type. All types are represented using their source
+     * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+     * Struct types are represented as fully qualified type names; e.g.
+     * `00000000000000000000000000000001::string::String` or
+     * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+     * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+     * 32 depending on the Move platform)
+     */
+    name: bcs.string(),
+  },
+});

package/src/_generated/zing_identity/deps/sui/object.ts

@@ -0,0 +1,16 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Sui object identifiers */
+
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::object";
+export const UID = new MoveStruct({
+  name: `${$moduleName}::UID`,
+  fields: {
+    id: bcs.Address,
+  },
+});

package/src/_generated/zing_identity/deps/sui/object_table.ts

@@ -0,0 +1,26 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * Similar to `sui::table`, an `ObjectTable<K, V>` is a map-like collection. But
+ * unlike `sui::table`, the values bound to these dynamic fields _must_ be objects
+ * themselves. This allows for the objects to still exist within in storage, which
+ * may be important for external tools. The difference is otherwise not observable
+ * from within Move.
+ */
+
+import * as object from "./object.js";
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::object_table";
+export const ObjectTable = new MoveStruct({
+  name: `${$moduleName}::ObjectTable`,
+  fields: {
+    /** the ID of this table */
+    id: object.UID,
+    /** the number of key-value pairs in the table */
+    size: bcs.u64(),
+  },
+});

package/src/_generated/zing_identity/deps/sui/table.ts

@@ -0,0 +1,38 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Sui's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+
+import * as object from "./object.js";
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::table";
+export const Table = new MoveStruct({
+  name: `${$moduleName}::Table`,
+  fields: {
+    /** the ID of this table */
+    id: object.UID,
+    /** the number of key-value pairs in the table */
+    size: bcs.u64(),
+  },
+});

package/src/_generated/zing_identity/deps/sui/vec_set.ts

@@ -0,0 +1,28 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+import type { BcsType } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::vec_set";
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet<K extends BcsType<any>>(
+  ...typeParameters: [K]
+): MoveStruct<{
+  contents: ReturnType<typeof bcs.vector<K>>;
+}> {
+  return new MoveStruct({
+    name: `${$moduleName}::VecSet<${typeParameters[0].name as K["name"]}>`,
+    fields: {
+      contents: bcs.vector(typeParameters[0]),
+    },
+  });
+}

package/src/_generated/zing_identity/ecdsa.ts

@@ -0,0 +1,166 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as object from "./deps/sui/object.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+
+const $moduleName = "@local-pkg/zing_identity::ecdsa";
+export const VerifiedEvent = new MoveStruct({
+  name: `${$moduleName}::VerifiedEvent`,
+  fields: {
+    is_verified: bcs.bool(),
+  },
+});
+export const Output = new MoveStruct({
+  name: `${$moduleName}::Output`,
+  fields: {
+    id: object.UID,
+    value: bcs.vector(bcs.u8()),
+  },
+});
+export interface Keccak256Arguments {
+  data: RawTransactionArgument<number[]>;
+  recipient: RawTransactionArgument<string>;
+}
+export interface Keccak256Options {
+  package?: string;
+  arguments:
+    | Keccak256Arguments
+    | [
+        data: RawTransactionArgument<number[]>,
+        recipient: RawTransactionArgument<string>,
+      ];
+}
+/** Hash the data using Keccak256, output an object with the hash to recipient. */
+export function keccak256(options: Keccak256Options) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = ["vector<u8>", "address"] satisfies string[];
+  const parameterNames = ["data", "recipient"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "ecdsa",
+      function: "keccak256",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface EcrecoverArguments {
+  signature: RawTransactionArgument<number[]>;
+  msg: RawTransactionArgument<number[]>;
+  recipient: RawTransactionArgument<string>;
+}
+export interface EcrecoverOptions {
+  package?: string;
+  arguments:
+    | EcrecoverArguments
+    | [
+        signature: RawTransactionArgument<number[]>,
+        msg: RawTransactionArgument<number[]>,
+        recipient: RawTransactionArgument<string>,
+      ];
+}
+/**
+ * Recover the public key using the signature and message, assuming the signature
+ * was produced over the Keccak256 hash of the message. Output an object with the
+ * recovered pubkey to recipient.
+ */
+export function ecrecover(options: EcrecoverOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = [
+    "vector<u8>",
+    "vector<u8>",
+    "address",
+  ] satisfies string[];
+  const parameterNames = ["signature", "msg", "recipient"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "ecdsa",
+      function: "ecrecover",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface EcrecoverToEthAddressArguments {
+  signature: RawTransactionArgument<number[]>;
+  msg: RawTransactionArgument<number[]>;
+}
+export interface EcrecoverToEthAddressOptions {
+  package?: string;
+  arguments:
+    | EcrecoverToEthAddressArguments
+    | [
+        signature: RawTransactionArgument<number[]>,
+        msg: RawTransactionArgument<number[]>,
+      ];
+}
+/**
+ * Recover the Ethereum address using the signature and message, assuming the
+ * signature was produced over the Keccak256 hash of the message. Output an object
+ * with the recovered address to recipient.
+ */
+export function ecrecoverToEthAddress(options: EcrecoverToEthAddressOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = ["vector<u8>", "vector<u8>"] satisfies string[];
+  const parameterNames = ["signature", "msg"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "ecdsa",
+      function: "ecrecover_to_eth_address",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface Secp256k1VerifyArguments {
+  signature: RawTransactionArgument<number[]>;
+  publicKey: RawTransactionArgument<number[]>;
+  msg: RawTransactionArgument<number[]>;
+}
+export interface Secp256k1VerifyOptions {
+  package?: string;
+  arguments:
+    | Secp256k1VerifyArguments
+    | [
+        signature: RawTransactionArgument<number[]>,
+        publicKey: RawTransactionArgument<number[]>,
+        msg: RawTransactionArgument<number[]>,
+      ];
+}
+/**
+ * Verified the secp256k1 signature using public key and message assuming Keccak
+ * was using when signing. Emit an is_verified event of the verification result.
+ */
+export function secp256k1Verify(options: Secp256k1VerifyOptions) {
+  const packageAddress = options.package ?? "@local-pkg/zing_identity";
+  const argumentsTypes = [
+    "vector<u8>",
+    "vector<u8>",
+    "vector<u8>",
+  ] satisfies string[];
+  const parameterNames = ["signature", "publicKey", "msg"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "ecdsa",
+      function: "secp256k1_verify",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}