wowok 1.8.2 → 2.1.9

package/dist/cjs/bcs/index.js

@@ -0,0 +1,79 @@
+"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 bcs_exports = {};
+__export(bcs_exports, {
+  BcsEnum: () => import_bcs3.BcsEnum,
+  BcsStruct: () => import_bcs3.BcsStruct,
+  BcsTuple: () => import_bcs3.BcsTuple,
+  BcsType: () => import_bcs3.BcsType,
+  TypeTagSerializer: () => import_type_tag_serializer.TypeTagSerializer,
+  bcs: () => suiBcs,
+  pureBcsSchemaFromTypeName: () => import_pure.pureBcsSchemaFromTypeName
+});
+module.exports = __toCommonJS(bcs_exports);
+var import_bcs = require("@mysten/bcs");
+var import_bcs2 = require("./bcs.js");
+var import_effects = require("./effects.js");
+var import_type_tag_serializer = require("./type-tag-serializer.js");
+var import_bcs3 = require("@mysten/bcs");
+var import_pure = require("./pure.js");
+const suiBcs = {
+  ...import_bcs.bcs,
+  U8: import_bcs.bcs.u8(),
+  U16: import_bcs.bcs.u16(),
+  U32: import_bcs.bcs.u32(),
+  U64: import_bcs.bcs.u64(),
+  U128: import_bcs.bcs.u128(),
+  U256: import_bcs.bcs.u256(),
+  ULEB128: import_bcs.bcs.uleb128(),
+  Bool: import_bcs.bcs.bool(),
+  String: import_bcs.bcs.string(),
+  Address: import_bcs2.Address,
+  AppId: import_bcs2.AppId,
+  Argument: import_bcs2.Argument,
+  CallArg: import_bcs2.CallArg,
+  Command: import_bcs2.Command,
+  CompressedSignature: import_bcs2.CompressedSignature,
+  GasData: import_bcs2.GasData,
+  Intent: import_bcs2.Intent,
+  IntentMessage: import_bcs2.IntentMessage,
+  IntentScope: import_bcs2.IntentScope,
+  IntentVersion: import_bcs2.IntentVersion,
+  MultiSig: import_bcs2.MultiSig,
+  MultiSigPkMap: import_bcs2.MultiSigPkMap,
+  MultiSigPublicKey: import_bcs2.MultiSigPublicKey,
+  ObjectArg: import_bcs2.ObjectArg,
+  ObjectDigest: import_bcs2.ObjectDigest,
+  Owner: import_bcs2.Owner,
+  PasskeyAuthenticator: import_bcs2.PasskeyAuthenticator,
+  ProgrammableMoveCall: import_bcs2.ProgrammableMoveCall,
+  ProgrammableTransaction: import_bcs2.ProgrammableTransaction,
+  PublicKey: import_bcs2.PublicKey,
+  SenderSignedData: import_bcs2.SenderSignedData,
+  SenderSignedTransaction: import_bcs2.SenderSignedTransaction,
+  SharedObjectRef: import_bcs2.SharedObjectRef,
+  StructTag: import_bcs2.StructTag,
+  SuiObjectRef: import_bcs2.SuiObjectRef,
+  TransactionData: import_bcs2.TransactionData,
+  TransactionDataV1: import_bcs2.TransactionDataV1,
+  TransactionEffects: import_effects.TransactionEffects,
+  TransactionExpiration: import_bcs2.TransactionExpiration,
+  TransactionKind: import_bcs2.TransactionKind,
+  TypeTag: import_bcs2.TypeTag
+};

package/dist/cjs/bcs/pure.d.ts

@@ -0,0 +1,22 @@
+import type { BcsType } from "@mysten/bcs";
+export type BasePureType = "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "bool" | "id" | "string" | "address";
+interface PureShapeByType {
+    u8: number;
+    u16: number;
+    u32: number;
+    u64: bigint | string | number;
+    u128: bigint | string | number;
+    u256: bigint | string | number;
+    bool: boolean;
+    string: string;
+    id: string | Uint8Array;
+    address: string | Uint8Array;
+}
+export type PureTypeName = BasePureType | `vector<${string}>` | `option<${string}>`;
+export type ValidPureTypeName<T extends string> = T extends BasePureType ? PureTypeName : T extends `vector<${infer U}>` ? ValidPureTypeName<U> : T extends `option<${infer U}>` ? ValidPureTypeName<U> : PureTypeValidationError<T>;
+export type ShapeFromPureTypeName<T extends PureTypeName> = T extends BasePureType ? PureShapeByType[T] : T extends `vector<${infer U extends PureTypeName}>` ? ShapeFromPureTypeName<U>[] : T extends `option<${infer U extends PureTypeName}>` ? ShapeFromPureTypeName<U> | null : never;
+type PureTypeValidationError<T extends string> = {
+    error: `Invalid Pure type name: ${T}`;
+} & {};
+export declare function pureBcsSchemaFromTypeName<T extends PureTypeName>(name: T extends PureTypeName ? ValidPureTypeName<T> : T): BcsType<ShapeFromPureTypeName<T>>;
+export {};

package/dist/cjs/bcs/pure.js

@@ -0,0 +1,62 @@
+"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 pure_exports = {};
+__export(pure_exports, {
+  pureBcsSchemaFromTypeName: () => pureBcsSchemaFromTypeName
+});
+module.exports = __toCommonJS(pure_exports);
+var import_bcs = require("@mysten/bcs");
+var import_bcs2 = require("./bcs.js");
+function pureBcsSchemaFromTypeName(name) {
+  switch (name) {
+    case "u8":
+      return import_bcs.bcs.u8();
+    case "u16":
+      return import_bcs.bcs.u16();
+    case "u32":
+      return import_bcs.bcs.u32();
+    case "u64":
+      return import_bcs.bcs.u64();
+    case "u128":
+      return import_bcs.bcs.u128();
+    case "u256":
+      return import_bcs.bcs.u256();
+    case "bool":
+      return import_bcs.bcs.bool();
+    case "string":
+      return import_bcs.bcs.string();
+    case "id":
+    case "address":
+      return import_bcs2.Address;
+  }
+  const generic = name.match(/^(vector|option)<(.+)>$/);
+  if (generic) {
+    const [kind, inner] = generic.slice(1);
+    if (kind === "vector") {
+      return import_bcs.bcs.vector(
+        pureBcsSchemaFromTypeName(inner)
+      );
+    } else {
+      return import_bcs.bcs.option(
+        pureBcsSchemaFromTypeName(inner)
+      );
+    }
+  }
+  throw new Error(`Invalid Pure type name: ${name}`);
+}

package/dist/cjs/bcs/type-tag-serializer.d.ts

@@ -0,0 +1,7 @@
+import type { TypeTag } from "./types.js";
+export declare class TypeTagSerializer {
+    static parseFromStr(str: string, normalizeAddress?: boolean): TypeTag;
+    static parseStructTypeArgs(str: string, normalizeAddress?: boolean): TypeTag[];
+    static tagToString(tag: TypeTag): string;
+}
+export declare function normalizeTypeTag(type: string): string;

package/dist/cjs/bcs/type-tag-serializer.js

@@ -0,0 +1,124 @@
+"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 type_tag_serializer_exports = {};
+__export(type_tag_serializer_exports, {
+  TypeTagSerializer: () => TypeTagSerializer,
+  normalizeTypeTag: () => normalizeTypeTag
+});
+module.exports = __toCommonJS(type_tag_serializer_exports);
+var import_bcs = require("@mysten/bcs");
+var import_sui_types = require("../utils/sui-types.js");
+const VECTOR_REGEX = /^vector<(.+)>$/;
+const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+class TypeTagSerializer {
+  static parseFromStr(str, normalizeAddress = false) {
+    if (str === "address") {
+      return { address: null };
+    } else if (str === "bool") {
+      return { bool: null };
+    } else if (str === "u8") {
+      return { u8: null };
+    } else if (str === "u16") {
+      return { u16: null };
+    } else if (str === "u32") {
+      return { u32: null };
+    } else if (str === "u64") {
+      return { u64: null };
+    } else if (str === "u128") {
+      return { u128: null };
+    } else if (str === "u256") {
+      return { u256: null };
+    } else if (str === "signer") {
+      return { signer: null };
+    }
+    const vectorMatch = str.match(VECTOR_REGEX);
+    if (vectorMatch) {
+      return {
+        vector: TypeTagSerializer.parseFromStr(
+          vectorMatch[1],
+          normalizeAddress
+        )
+      };
+    }
+    const structMatch = str.match(STRUCT_REGEX);
+    if (structMatch) {
+      const address = normalizeAddress ? (0, import_sui_types.normalizeWowAddress)(structMatch[1]) : structMatch[1];
+      return {
+        struct: {
+          address,
+          module: structMatch[2],
+          name: structMatch[3],
+          typeParams: structMatch[5] === void 0 ? [] : TypeTagSerializer.parseStructTypeArgs(
+            structMatch[5],
+            normalizeAddress
+          )
+        }
+      };
+    }
+    throw new Error(
+      `Encountered unexpected token when parsing type args for ${str}`
+    );
+  }
+  static parseStructTypeArgs(str, normalizeAddress = false) {
+    return (0, import_bcs.splitGenericParameters)(str).map(
+      (tok) => TypeTagSerializer.parseFromStr(tok, normalizeAddress)
+    );
+  }
+  static tagToString(tag) {
+    if ("bool" in tag) {
+      return "bool";
+    }
+    if ("u8" in tag) {
+      return "u8";
+    }
+    if ("u16" in tag) {
+      return "u16";
+    }
+    if ("u32" in tag) {
+      return "u32";
+    }
+    if ("u64" in tag) {
+      return "u64";
+    }
+    if ("u128" in tag) {
+      return "u128";
+    }
+    if ("u256" in tag) {
+      return "u256";
+    }
+    if ("address" in tag) {
+      return "address";
+    }
+    if ("signer" in tag) {
+      return "signer";
+    }
+    if ("vector" in tag) {
+      return `vector<${TypeTagSerializer.tagToString(tag.vector)}>`;
+    }
+    if ("struct" in tag) {
+      const struct = tag.struct;
+      const typeParams = struct.typeParams.map(TypeTagSerializer.tagToString).join(", ");
+      return `${struct.address}::${struct.module}::${struct.name}${typeParams ? `<${typeParams}>` : ""}`;
+    }
+    throw new Error("Invalid TypeTag");
+  }
+}
+function normalizeTypeTag(type) {
+  return TypeTagSerializer.tagToString(TypeTagSerializer.parseFromStr(type));
+}

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

@@ -0,0 +1,114 @@
+export type SharedObjectRef = {
+    /** Hex code as string representing the object id */
+    objectId: string;
+    /** The version the object was shared at */
+    initialSharedVersion: number | string;
+    /** Whether reference is mutable */
+    mutable: boolean;
+};
+export type SuiObjectRef = {
+    /** Base64 string representing the object digest */
+    objectId: string;
+    /** Object version */
+    version: number | string;
+    /** Hex code as string representing the object id */
+    digest: string;
+};
+/**
+ * An object argument.
+ */
+export type ObjectArg = {
+    ImmOrOwnedObject: SuiObjectRef;
+} | {
+    SharedObject: SharedObjectRef;
+} | {
+    Receiving: SuiObjectRef;
+};
+export type ObjectCallArg = {
+    Object: ObjectArg;
+};
+/**
+ * A pure argument.
+ */
+export type PureArg = {
+    Pure: Array<number>;
+};
+export declare function isPureArg(arg: any): arg is PureArg;
+/**
+ * An argument for the transaction. It is a 'meant' enum which expects to have
+ * one of the optional properties. If not, the BCS error will be thrown while
+ * attempting to form a transaction.
+ *
+ * Example:
+ * ```js
+ * let arg1: CallArg = { Object: { Shared: {
+ *   objectId: '5460cf92b5e3e7067aaace60d88324095fd22944',
+ *   initialSharedVersion: 1,
+ *   mutable: true,
+ * } } };
+ * let arg2: CallArg = { Pure: bcs.ser(BCS.STRING, 100000).toBytes() };
+ * let arg3: CallArg = { Object: { ImmOrOwned: {
+ *   objectId: '4047d2e25211d87922b6650233bd0503a6734279',
+ *   version: 1,
+ *   digest: 'bCiANCht4O9MEUhuYjdRCqRPZjr2rJ8MfqNiwyhmRgA='
+ * } } };
+ * ```
+ *
+ * For `Pure` arguments BCS is required. You must encode the values with BCS according
+ * to the type required by the called function. Pure accepts only serialized values
+ */
+export type CallArg = PureArg | ObjectCallArg;
+/**
+ * Kind of a TypeTag which is represented by a Move type identifier.
+ */
+export type StructTag = {
+    address: string;
+    module: string;
+    name: string;
+    typeParams: TypeTag[];
+};
+/**
+ * Sui TypeTag object. A decoupled `0x...::module::Type<???>` parameter.
+ */
+export type TypeTag = {
+    bool: null | true;
+} | {
+    u8: null | true;
+} | {
+    u64: null | true;
+} | {
+    u128: null | true;
+} | {
+    address: null | true;
+} | {
+    signer: null | true;
+} | {
+    vector: TypeTag;
+} | {
+    struct: StructTag;
+} | {
+    u16: null | true;
+} | {
+    u32: null | true;
+} | {
+    u256: null | true;
+};
+/**
+ * The GasData to be used in the transaction.
+ */
+export type GasData = {
+    payment: SuiObjectRef[];
+    owner: string;
+    price: number;
+    budget: number;
+};
+/**
+ * TransactionExpiration
+ *
+ * Indications the expiration time for a transaction.
+ */
+export type TransactionExpiration = {
+    None: null;
+} | {
+    Epoch: number;
+};

package/dist/cjs/bcs/types.js

@@ -0,0 +1,26 @@
+"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 types_exports = {};
+__export(types_exports, {
+  isPureArg: () => isPureArg
+});
+module.exports = __toCommonJS(types_exports);
+function isPureArg(arg) {
+  return arg.Pure !== void 0;
+}

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

@@ -0,0 +1,5 @@
+export { type JsonRpcTransport as SuiTransport, type JsonRpcTransportRequestOptions as SuiTransportRequestOptions, type JsonRpcTransportSubscribeOptions as SuiTransportSubscribeOptions, type HttpHeaders, type JsonRpcHTTPTransportOptions as SuiHTTPTransportOptions, JsonRpcHTTPTransport as SuiHTTPTransport, } from "../jsonRpc/http-transport.js";
+export { getFullnodeUrl, ENTRYPOINT } from "./network.js";
+export { type SuiJsonRpcClientOptions as SuiClientOptions, type PaginationArguments, type OrderArguments, isSuiJsonRpcClient as isSuiClient, SuiJsonRpcClient as SuiClient, } from "../jsonRpc/client.js";
+export { SuiHTTPStatusError, SuiHTTPTransportError, JsonRpcError, } from "../jsonRpc/errors.js";
+export type { SuiTransactionBlockResponseOptions, CoinStruct, SuiMoveNormalizedType, CoinBalance, PaginatedCoins, SuiTransactionBlockResponse, CoinMetadata, ObjectResponseError, ExecuteTransactionBlockParams, } from "../jsonRpc/types/index.js";

package/dist/cjs/client/index.js

@@ -0,0 +1,34 @@
+"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 client_exports = {};
+__export(client_exports, {
+  ENTRYPOINT: () => import_network.ENTRYPOINT,
+  JsonRpcError: () => import_errors.JsonRpcError,
+  SuiClient: () => import_client.SuiJsonRpcClient,
+  SuiHTTPStatusError: () => import_errors.SuiHTTPStatusError,
+  SuiHTTPTransport: () => import_http_transport.JsonRpcHTTPTransport,
+  SuiHTTPTransportError: () => import_errors.SuiHTTPTransportError,
+  getFullnodeUrl: () => import_network.getFullnodeUrl,
+  isSuiClient: () => import_client.isSuiJsonRpcClient
+});
+module.exports = __toCommonJS(client_exports);
+var import_http_transport = require("../jsonRpc/http-transport.js");
+var import_network = require("./network.js");
+var import_client = require("../jsonRpc/client.js");
+var import_errors = require("../jsonRpc/errors.js");

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

@@ -0,0 +1,5 @@
+export declare enum ENTRYPOINT {
+    Testnet = "testnet",
+    Localnet = "localnet"
+}
+export declare function getFullnodeUrl(network: ENTRYPOINT): "https://fullnode.testnet.wowok.net:443" | "http://127.0.0.1:9000";

package/dist/cjs/client/network.js

@@ -0,0 +1,43 @@
+"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 network_exports = {};
+__export(network_exports, {
+  ENTRYPOINT: () => ENTRYPOINT,
+  getFullnodeUrl: () => getFullnodeUrl
+});
+module.exports = __toCommonJS(network_exports);
+var ENTRYPOINT = /* @__PURE__ */ ((ENTRYPOINT2) => {
+  ENTRYPOINT2["Testnet"] = "testnet";
+  ENTRYPOINT2["Localnet"] = "localnet";
+  return ENTRYPOINT2;
+})(ENTRYPOINT || {});
+function getFullnodeUrl(network) {
+  switch (network) {
+    /*case ENTRYPOINT.Mainnet:
+    	return "https://fullnode.mainnet.wowok.net:443";*/
+    case "testnet" /* Testnet */:
+      return "https://fullnode.testnet.wowok.net:443";
+    /*case ENTRYPOINT.Devnet:
+    	return "https://fullnode.devnet.wowok.net:443";*/
+    case "localnet" /* Localnet */:
+      return "http://127.0.0.1:9000";
+    default:
+      throw new Error(`Unknown network: ${network}`);
+  }
+}

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

@@ -0,0 +1,7 @@
+export { type SerializeSignatureInput, toSerializedSignature, parseSerializedSignature, } from "./signature.js";
+export { SIGNATURE_SCHEME_TO_FLAG, SIGNATURE_SCHEME_TO_SIZE, SIGNATURE_FLAG_TO_SCHEME, type SignatureScheme, type SignatureFlag, } from "./signature-scheme.js";
+export { isValidHardenedPath, isValidBIP32Path, mnemonicToSeed, mnemonicToSeedHex, } from "./mnemonics.js";
+export { messageWithIntent } from "./intent.js";
+export type { IntentScope } from "./intent.js";
+export { PRIVATE_KEY_SIZE, LEGACY_PRIVATE_KEY_SIZE, W_PRIVATE_KEY_PREFIX, type ParsedKeypair, type SignatureWithBytes, Signer, Keypair, decodeWowPrivateKey, encodeWowPrivateKey, } from "./keypair.js";
+export { PublicKey } from "./publickey.js";

package/dist/cjs/cryptography/index.js

@@ -0,0 +1,46 @@
+"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 cryptography_exports = {};
+__export(cryptography_exports, {
+  Keypair: () => import_keypair.Keypair,
+  LEGACY_PRIVATE_KEY_SIZE: () => import_keypair.LEGACY_PRIVATE_KEY_SIZE,
+  PRIVATE_KEY_SIZE: () => import_keypair.PRIVATE_KEY_SIZE,
+  PublicKey: () => import_publickey.PublicKey,
+  SIGNATURE_FLAG_TO_SCHEME: () => import_signature_scheme.SIGNATURE_FLAG_TO_SCHEME,
+  SIGNATURE_SCHEME_TO_FLAG: () => import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG,
+  SIGNATURE_SCHEME_TO_SIZE: () => import_signature_scheme.SIGNATURE_SCHEME_TO_SIZE,
+  Signer: () => import_keypair.Signer,
+  W_PRIVATE_KEY_PREFIX: () => import_keypair.W_PRIVATE_KEY_PREFIX,
+  decodeWowPrivateKey: () => import_keypair.decodeWowPrivateKey,
+  encodeWowPrivateKey: () => import_keypair.encodeWowPrivateKey,
+  isValidBIP32Path: () => import_mnemonics.isValidBIP32Path,
+  isValidHardenedPath: () => import_mnemonics.isValidHardenedPath,
+  messageWithIntent: () => import_intent.messageWithIntent,
+  mnemonicToSeed: () => import_mnemonics.mnemonicToSeed,
+  mnemonicToSeedHex: () => import_mnemonics.mnemonicToSeedHex,
+  parseSerializedSignature: () => import_signature.parseSerializedSignature,
+  toSerializedSignature: () => import_signature.toSerializedSignature
+});
+module.exports = __toCommonJS(cryptography_exports);
+var import_signature = require("./signature.js");
+var import_signature_scheme = require("./signature-scheme.js");
+var import_mnemonics = require("./mnemonics.js");
+var import_intent = require("./intent.js");
+var import_keypair = require("./keypair.js");
+var import_publickey = require("./publickey.js");

package/dist/cjs/cryptography/intent.d.ts

@@ -0,0 +1,6 @@
+import { bcs } from "../bcs/index.js";
+export type IntentScope = Exclude<keyof typeof bcs.IntentScope.$inferType, "$kind">;
+/**
+ * Inserts a domain separator for a message that is being signed
+ */
+export declare function messageWithIntent(scope: IntentScope, message: Uint8Array): Uint8Array<ArrayBuffer>;

package/dist/cjs/cryptography/intent.js

@@ -0,0 +1,34 @@
+"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 intent_exports = {};
+__export(intent_exports, {
+  messageWithIntent: () => messageWithIntent
+});
+module.exports = __toCommonJS(intent_exports);
+var import_bcs = require("../bcs/index.js");
+function messageWithIntent(scope, message) {
+  return import_bcs.bcs.IntentMessage(import_bcs.bcs.bytes(message.length)).serialize({
+    intent: {
+      scope: { [scope]: true },
+      version: { V0: true },
+      appId: { Sui: true }
+    },
+    value: message
+  }).toBytes();
+}