wowok 1.8.2 → 2.1.9

package/dist/cjs/grpc/proto/sui/rpc/v2/move_package.js

@@ -0,0 +1,485 @@
+"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 move_package_exports = {};
+__export(move_package_exports, {
+  Ability: () => Ability,
+  DatatypeDescriptor: () => DatatypeDescriptor,
+  DatatypeDescriptor_DatatypeKind: () => DatatypeDescriptor_DatatypeKind,
+  FieldDescriptor: () => FieldDescriptor,
+  FunctionDescriptor: () => FunctionDescriptor,
+  FunctionDescriptor_Visibility: () => FunctionDescriptor_Visibility,
+  Linkage: () => Linkage,
+  Module: () => Module,
+  OpenSignature: () => OpenSignature,
+  OpenSignatureBody: () => OpenSignatureBody,
+  OpenSignatureBody_Type: () => OpenSignatureBody_Type,
+  OpenSignature_Reference: () => OpenSignature_Reference,
+  Package: () => Package,
+  TypeOrigin: () => TypeOrigin,
+  TypeParameter: () => TypeParameter,
+  VariantDescriptor: () => VariantDescriptor
+});
+module.exports = __toCommonJS(move_package_exports);
+var import_runtime = require("@protobuf-ts/runtime");
+var DatatypeDescriptor_DatatypeKind = /* @__PURE__ */ ((DatatypeDescriptor_DatatypeKind2) => {
+  DatatypeDescriptor_DatatypeKind2[DatatypeDescriptor_DatatypeKind2["DATATYPE_KIND_UNKNOWN"] = 0] = "DATATYPE_KIND_UNKNOWN";
+  DatatypeDescriptor_DatatypeKind2[DatatypeDescriptor_DatatypeKind2["STRUCT"] = 1] = "STRUCT";
+  DatatypeDescriptor_DatatypeKind2[DatatypeDescriptor_DatatypeKind2["ENUM"] = 2] = "ENUM";
+  return DatatypeDescriptor_DatatypeKind2;
+})(DatatypeDescriptor_DatatypeKind || {});
+var OpenSignatureBody_Type = /* @__PURE__ */ ((OpenSignatureBody_Type2) => {
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["TYPE_UNKNOWN"] = 0] = "TYPE_UNKNOWN";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["ADDRESS"] = 1] = "ADDRESS";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["BOOL"] = 2] = "BOOL";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["U8"] = 3] = "U8";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["U16"] = 4] = "U16";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["U32"] = 5] = "U32";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["U64"] = 6] = "U64";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["U128"] = 7] = "U128";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["U256"] = 8] = "U256";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["VECTOR"] = 9] = "VECTOR";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["DATATYPE"] = 10] = "DATATYPE";
+  OpenSignatureBody_Type2[OpenSignatureBody_Type2["TYPE_PARAMETER"] = 11] = "TYPE_PARAMETER";
+  return OpenSignatureBody_Type2;
+})(OpenSignatureBody_Type || {});
+var FunctionDescriptor_Visibility = /* @__PURE__ */ ((FunctionDescriptor_Visibility2) => {
+  FunctionDescriptor_Visibility2[FunctionDescriptor_Visibility2["VISIBILITY_UNKNOWN"] = 0] = "VISIBILITY_UNKNOWN";
+  FunctionDescriptor_Visibility2[FunctionDescriptor_Visibility2["PRIVATE"] = 1] = "PRIVATE";
+  FunctionDescriptor_Visibility2[FunctionDescriptor_Visibility2["PUBLIC"] = 2] = "PUBLIC";
+  FunctionDescriptor_Visibility2[FunctionDescriptor_Visibility2["FRIEND"] = 3] = "FRIEND";
+  return FunctionDescriptor_Visibility2;
+})(FunctionDescriptor_Visibility || {});
+var OpenSignature_Reference = /* @__PURE__ */ ((OpenSignature_Reference2) => {
+  OpenSignature_Reference2[OpenSignature_Reference2["REFERENCE_UNKNOWN"] = 0] = "REFERENCE_UNKNOWN";
+  OpenSignature_Reference2[OpenSignature_Reference2["IMMUTABLE"] = 1] = "IMMUTABLE";
+  OpenSignature_Reference2[OpenSignature_Reference2["MUTABLE"] = 2] = "MUTABLE";
+  return OpenSignature_Reference2;
+})(OpenSignature_Reference || {});
+var Ability = /* @__PURE__ */ ((Ability2) => {
+  Ability2[Ability2["ABILITY_UNKNOWN"] = 0] = "ABILITY_UNKNOWN";
+  Ability2[Ability2["COPY"] = 1] = "COPY";
+  Ability2[Ability2["DROP"] = 2] = "DROP";
+  Ability2[Ability2["STORE"] = 3] = "STORE";
+  Ability2[Ability2["KEY"] = 4] = "KEY";
+  return Ability2;
+})(Ability || {});
+class Package$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.Package", [
+      {
+        no: 1,
+        name: "storage_id",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "original_id",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "version",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+      },
+      {
+        no: 4,
+        name: "modules",
+        kind: "message",
+        repeat: 1,
+        T: () => Module
+      },
+      {
+        no: 5,
+        name: "type_origins",
+        kind: "message",
+        repeat: 1,
+        T: () => TypeOrigin
+      },
+      {
+        no: 6,
+        name: "linkage",
+        kind: "message",
+        repeat: 1,
+        T: () => Linkage
+      }
+    ]);
+  }
+}
+const Package = new Package$Type();
+class Module$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.Module", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "contents",
+        kind: "scalar",
+        opt: true,
+        T: 12
+      },
+      {
+        no: 3,
+        name: "datatypes",
+        kind: "message",
+        repeat: 1,
+        T: () => DatatypeDescriptor
+      },
+      {
+        no: 4,
+        name: "functions",
+        kind: "message",
+        repeat: 1,
+        T: () => FunctionDescriptor
+      }
+    ]);
+  }
+}
+const Module = new Module$Type();
+class DatatypeDescriptor$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.DatatypeDescriptor", [
+      {
+        no: 1,
+        name: "type_name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "defining_id",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "module",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 4,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 5,
+        name: "abilities",
+        kind: "enum",
+        repeat: 1,
+        T: () => ["sui.rpc.v2.Ability", Ability]
+      },
+      {
+        no: 6,
+        name: "type_parameters",
+        kind: "message",
+        repeat: 1,
+        T: () => TypeParameter
+      },
+      {
+        no: 7,
+        name: "kind",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "sui.rpc.v2.DatatypeDescriptor.DatatypeKind",
+          DatatypeDescriptor_DatatypeKind
+        ]
+      },
+      {
+        no: 8,
+        name: "fields",
+        kind: "message",
+        repeat: 1,
+        T: () => FieldDescriptor
+      },
+      {
+        no: 9,
+        name: "variants",
+        kind: "message",
+        repeat: 1,
+        T: () => VariantDescriptor
+      }
+    ]);
+  }
+}
+const DatatypeDescriptor = new DatatypeDescriptor$Type();
+class TypeParameter$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.TypeParameter", [
+      {
+        no: 1,
+        name: "constraints",
+        kind: "enum",
+        repeat: 1,
+        T: () => ["sui.rpc.v2.Ability", Ability]
+      },
+      {
+        no: 2,
+        name: "is_phantom",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      }
+    ]);
+  }
+}
+const TypeParameter = new TypeParameter$Type();
+class FieldDescriptor$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.FieldDescriptor", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "position",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 3,
+        name: "type",
+        kind: "message",
+        T: () => OpenSignatureBody
+      }
+    ]);
+  }
+}
+const FieldDescriptor = new FieldDescriptor$Type();
+class VariantDescriptor$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.VariantDescriptor", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "position",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      },
+      {
+        no: 3,
+        name: "fields",
+        kind: "message",
+        repeat: 1,
+        T: () => FieldDescriptor
+      }
+    ]);
+  }
+}
+const VariantDescriptor = new VariantDescriptor$Type();
+class OpenSignatureBody$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.OpenSignatureBody", [
+      {
+        no: 1,
+        name: "type",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "sui.rpc.v2.OpenSignatureBody.Type",
+          OpenSignatureBody_Type
+        ]
+      },
+      {
+        no: 2,
+        name: "type_name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "type_parameter_instantiation",
+        kind: "message",
+        repeat: 1,
+        T: () => OpenSignatureBody
+      },
+      {
+        no: 4,
+        name: "type_parameter",
+        kind: "scalar",
+        opt: true,
+        T: 13
+      }
+    ]);
+  }
+}
+const OpenSignatureBody = new OpenSignatureBody$Type();
+class FunctionDescriptor$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.FunctionDescriptor", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 5,
+        name: "visibility",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "sui.rpc.v2.FunctionDescriptor.Visibility",
+          FunctionDescriptor_Visibility
+        ]
+      },
+      {
+        no: 6,
+        name: "is_entry",
+        kind: "scalar",
+        opt: true,
+        T: 8
+      },
+      {
+        no: 7,
+        name: "type_parameters",
+        kind: "message",
+        repeat: 1,
+        T: () => TypeParameter
+      },
+      {
+        no: 8,
+        name: "parameters",
+        kind: "message",
+        repeat: 1,
+        T: () => OpenSignature
+      },
+      {
+        no: 9,
+        name: "returns",
+        kind: "message",
+        repeat: 1,
+        T: () => OpenSignature
+      }
+    ]);
+  }
+}
+const FunctionDescriptor = new FunctionDescriptor$Type();
+class OpenSignature$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.OpenSignature", [
+      {
+        no: 1,
+        name: "reference",
+        kind: "enum",
+        opt: true,
+        T: () => [
+          "sui.rpc.v2.OpenSignature.Reference",
+          OpenSignature_Reference
+        ]
+      },
+      {
+        no: 2,
+        name: "body",
+        kind: "message",
+        T: () => OpenSignatureBody
+      }
+    ]);
+  }
+}
+const OpenSignature = new OpenSignature$Type();
+class TypeOrigin$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.TypeOrigin", [
+      {
+        no: 1,
+        name: "module_name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "datatype_name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "package_id",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      }
+    ]);
+  }
+}
+const TypeOrigin = new TypeOrigin$Type();
+class Linkage$Type extends import_runtime.MessageType {
+  constructor() {
+    super("sui.rpc.v2.Linkage", [
+      {
+        no: 1,
+        name: "original_id",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 2,
+        name: "upgraded_id",
+        kind: "scalar",
+        opt: true,
+        T: 9
+      },
+      {
+        no: 3,
+        name: "upgraded_version",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+      }
+    ]);
+  }
+}
+const Linkage = new Linkage$Type();

package/dist/cjs/grpc/proto/sui/rpc/v2/move_package_service.client.d.ts

@@ -0,0 +1,61 @@
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import type { ListPackageVersionsResponse } from "./move_package_service.js";
+import type { ListPackageVersionsRequest } from "./move_package_service.js";
+import type { GetFunctionResponse } from "./move_package_service.js";
+import type { GetFunctionRequest } from "./move_package_service.js";
+import type { GetDatatypeResponse } from "./move_package_service.js";
+import type { GetDatatypeRequest } from "./move_package_service.js";
+import type { GetPackageResponse } from "./move_package_service.js";
+import type { GetPackageRequest } from "./move_package_service.js";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service sui.rpc.v2.MovePackageService
+ */
+export interface IMovePackageServiceClient {
+    /**
+     * @generated from protobuf rpc: GetPackage(sui.rpc.v2.GetPackageRequest) returns (sui.rpc.v2.GetPackageResponse);
+     */
+    getPackage(input: GetPackageRequest, options?: RpcOptions): UnaryCall<GetPackageRequest, GetPackageResponse>;
+    /**
+     * @generated from protobuf rpc: GetDatatype(sui.rpc.v2.GetDatatypeRequest) returns (sui.rpc.v2.GetDatatypeResponse);
+     */
+    getDatatype(input: GetDatatypeRequest, options?: RpcOptions): UnaryCall<GetDatatypeRequest, GetDatatypeResponse>;
+    /**
+     * @generated from protobuf rpc: GetFunction(sui.rpc.v2.GetFunctionRequest) returns (sui.rpc.v2.GetFunctionResponse);
+     */
+    getFunction(input: GetFunctionRequest, options?: RpcOptions): UnaryCall<GetFunctionRequest, GetFunctionResponse>;
+    /**
+     * @generated from protobuf rpc: ListPackageVersions(sui.rpc.v2.ListPackageVersionsRequest) returns (sui.rpc.v2.ListPackageVersionsResponse);
+     */
+    listPackageVersions(input: ListPackageVersionsRequest, options?: RpcOptions): UnaryCall<ListPackageVersionsRequest, ListPackageVersionsResponse>;
+}
+/**
+ * @generated from protobuf service sui.rpc.v2.MovePackageService
+ */
+export declare class MovePackageServiceClient implements IMovePackageServiceClient, ServiceInfo {
+    private readonly _transport;
+    typeName: string;
+    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
+    options: {
+        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
+    };
+    constructor(_transport: RpcTransport);
+    /**
+     * @generated from protobuf rpc: GetPackage(sui.rpc.v2.GetPackageRequest) returns (sui.rpc.v2.GetPackageResponse);
+     */
+    getPackage(input: GetPackageRequest, options?: RpcOptions): UnaryCall<GetPackageRequest, GetPackageResponse>;
+    /**
+     * @generated from protobuf rpc: GetDatatype(sui.rpc.v2.GetDatatypeRequest) returns (sui.rpc.v2.GetDatatypeResponse);
+     */
+    getDatatype(input: GetDatatypeRequest, options?: RpcOptions): UnaryCall<GetDatatypeRequest, GetDatatypeResponse>;
+    /**
+     * @generated from protobuf rpc: GetFunction(sui.rpc.v2.GetFunctionRequest) returns (sui.rpc.v2.GetFunctionResponse);
+     */
+    getFunction(input: GetFunctionRequest, options?: RpcOptions): UnaryCall<GetFunctionRequest, GetFunctionResponse>;
+    /**
+     * @generated from protobuf rpc: ListPackageVersions(sui.rpc.v2.ListPackageVersionsRequest) returns (sui.rpc.v2.ListPackageVersionsResponse);
+     */
+    listPackageVersions(input: ListPackageVersionsRequest, options?: RpcOptions): UnaryCall<ListPackageVersionsRequest, ListPackageVersionsResponse>;
+}

package/dist/cjs/grpc/proto/sui/rpc/v2/move_package_service.client.js

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var move_package_service_client_exports = {};
+__export(move_package_service_client_exports, {
+  MovePackageServiceClient: () => MovePackageServiceClient
+});
+module.exports = __toCommonJS(move_package_service_client_exports);
+var import_move_package_service = require("./move_package_service.js");
+var import_runtime_rpc = require("@protobuf-ts/runtime-rpc");
+class MovePackageServiceClient {
+  constructor(_transport) {
+    __publicField(this, "_transport", _transport);
+    __publicField(this, "typeName", import_move_package_service.MovePackageService.typeName);
+    __publicField(this, "methods", import_move_package_service.MovePackageService.methods);
+    __publicField(this, "options", import_move_package_service.MovePackageService.options);
+  }
+  /**
+   * @generated from protobuf rpc: GetPackage(sui.rpc.v2.GetPackageRequest) returns (sui.rpc.v2.GetPackageResponse);
+   */
+  getPackage(input, options) {
+    const method = this.methods[0], opt = this._transport.mergeOptions(options);
+    return (0, import_runtime_rpc.stackIntercept)(
+      "unary",
+      this._transport,
+      method,
+      opt,
+      input
+    );
+  }
+  /**
+   * @generated from protobuf rpc: GetDatatype(sui.rpc.v2.GetDatatypeRequest) returns (sui.rpc.v2.GetDatatypeResponse);
+   */
+  getDatatype(input, options) {
+    const method = this.methods[1], opt = this._transport.mergeOptions(options);
+    return (0, import_runtime_rpc.stackIntercept)(
+      "unary",
+      this._transport,
+      method,
+      opt,
+      input
+    );
+  }
+  /**
+   * @generated from protobuf rpc: GetFunction(sui.rpc.v2.GetFunctionRequest) returns (sui.rpc.v2.GetFunctionResponse);
+   */
+  getFunction(input, options) {
+    const method = this.methods[2], opt = this._transport.mergeOptions(options);
+    return (0, import_runtime_rpc.stackIntercept)(
+      "unary",
+      this._transport,
+      method,
+      opt,
+      input
+    );
+  }
+  /**
+   * @generated from protobuf rpc: ListPackageVersions(sui.rpc.v2.ListPackageVersionsRequest) returns (sui.rpc.v2.ListPackageVersionsResponse);
+   */
+  listPackageVersions(input, options) {
+    const method = this.methods[3], opt = this._transport.mergeOptions(options);
+    return (0, import_runtime_rpc.stackIntercept)("unary", this._transport, method, opt, input);
+  }
+}