@haneullabs/haneul 0.1.0

package/dist/cjs/utils/index.js

@@ -0,0 +1,69 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  GEUNHWA_PER_HANEUL: () => import_constants.GEUNHWA_PER_HANEUL,
+  HANEUL_ADDRESS_LENGTH: () => import_haneul_types.HANEUL_ADDRESS_LENGTH,
+  HANEUL_CLOCK_OBJECT_ID: () => import_constants.HANEUL_CLOCK_OBJECT_ID,
+  HANEUL_DECIMALS: () => import_constants.HANEUL_DECIMALS,
+  HANEUL_FRAMEWORK_ADDRESS: () => import_constants.HANEUL_FRAMEWORK_ADDRESS,
+  HANEUL_RANDOM_OBJECT_ID: () => import_constants.HANEUL_RANDOM_OBJECT_ID,
+  HANEUL_SYSTEM_ADDRESS: () => import_constants.HANEUL_SYSTEM_ADDRESS,
+  HANEUL_SYSTEM_MODULE_NAME: () => import_constants.HANEUL_SYSTEM_MODULE_NAME,
+  HANEUL_SYSTEM_STATE_OBJECT_ID: () => import_constants.HANEUL_SYSTEM_STATE_OBJECT_ID,
+  HANEUL_TYPE_ARG: () => import_constants.HANEUL_TYPE_ARG,
+  MOVE_STDLIB_ADDRESS: () => import_constants.MOVE_STDLIB_ADDRESS,
+  deriveDynamicFieldID: () => import_dynamic_fields.deriveDynamicFieldID,
+  deriveObjectID: () => import_derived_objects.deriveObjectID,
+  formatAddress: () => import_format.formatAddress,
+  formatDigest: () => import_format.formatDigest,
+  fromB64: () => import_bcs.fromB64,
+  fromBase58: () => import_bcs.fromBase58,
+  fromBase64: () => import_bcs.fromBase64,
+  fromHEX: () => import_bcs.fromHEX,
+  fromHex: () => import_bcs.fromHex,
+  isValidHaneulAddress: () => import_haneul_types.isValidHaneulAddress,
+  isValidHaneulNSName: () => import_haneulns.isValidHaneulNSName,
+  isValidHaneulObjectId: () => import_haneul_types.isValidHaneulObjectId,
+  isValidNamedPackage: () => import_move_registry.isValidNamedPackage,
+  isValidNamedType: () => import_move_registry.isValidNamedType,
+  isValidTransactionDigest: () => import_haneul_types.isValidTransactionDigest,
+  normalizeHaneulAddress: () => import_haneul_types.normalizeHaneulAddress,
+  normalizeHaneulNSName: () => import_haneulns.normalizeHaneulNSName,
+  normalizeHaneulObjectId: () => import_haneul_types.normalizeHaneulObjectId,
+  normalizeStructTag: () => import_haneul_types.normalizeStructTag,
+  normalizeTypeTag: () => import_type_tag_serializer.normalizeTypeTag,
+  parseStructTag: () => import_haneul_types.parseStructTag,
+  toB64: () => import_bcs.toB64,
+  toBase58: () => import_bcs.toBase58,
+  toBase64: () => import_bcs.toBase64,
+  toHEX: () => import_bcs.toHEX,
+  toHex: () => import_bcs.toHex
+});
+module.exports = __toCommonJS(utils_exports);
+var import_format = require("./format.js");
+var import_haneul_types = require("./haneul-types.js");
+var import_bcs = require("@haneullabs/bcs");
+var import_haneulns = require("./haneulns.js");
+var import_constants = require("./constants.js");
+var import_move_registry = require("./move-registry.js");
+var import_dynamic_fields = require("./dynamic-fields.js");
+var import_derived_objects = require("./derived-objects.js");
+var import_type_tag_serializer = require("../bcs/type-tag-serializer.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/utils/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport { formatAddress, formatDigest } from './format.js';\nexport {\n\tisValidHaneulAddress,\n\tisValidHaneulObjectId,\n\tisValidTransactionDigest,\n\tnormalizeStructTag,\n\tnormalizeHaneulAddress,\n\tnormalizeHaneulObjectId,\n\tparseStructTag,\n\tHANEUL_ADDRESS_LENGTH,\n} from './haneul-types.js';\n\nexport {\n\tfromB64,\n\ttoB64,\n\tfromHEX,\n\ttoHex,\n\ttoHEX,\n\tfromHex,\n\tfromBase64,\n\ttoBase64,\n\tfromBase58,\n\ttoBase58,\n} from '@haneullabs/bcs';\nexport { isValidHaneulNSName, normalizeHaneulNSName } from './haneulns.js';\n\nexport {\n\tHANEUL_DECIMALS,\n\tGEUNHWA_PER_HANEUL,\n\tMOVE_STDLIB_ADDRESS,\n\tHANEUL_FRAMEWORK_ADDRESS,\n\tHANEUL_SYSTEM_ADDRESS,\n\tHANEUL_CLOCK_OBJECT_ID,\n\tHANEUL_SYSTEM_MODULE_NAME,\n\tHANEUL_TYPE_ARG,\n\tHANEUL_SYSTEM_STATE_OBJECT_ID,\n\tHANEUL_RANDOM_OBJECT_ID,\n} from './constants.js';\n\nexport { isValidNamedPackage, isValidNamedType } from './move-registry.js';\n\nexport { deriveDynamicFieldID } from './dynamic-fields.js';\n\nexport { deriveObjectID } from './derived-objects.js';\nexport { normalizeTypeTag } from '../bcs/type-tag-serializer.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAA4C;AAC5C,0BASO;AAEP,iBAWO;AACP,sBAA2D;AAE3D,uBAWO;AAEP,2BAAsD;AAEtD,4BAAqC;AAErC,6BAA+B;AAC/B,iCAAiC;",
+  "names": []
+}

package/dist/cjs/utils/move-registry.d.ts

@@ -0,0 +1,6 @@
+export declare const isValidNamedPackage: (name: string) => boolean;
+/**
+ * Checks if a type contains valid named packages.
+ * This DOES NOT check if the type is a valid Move type.
+ */
+export declare const isValidNamedType: (type: string) => boolean;

package/dist/cjs/utils/move-registry.js

@@ -0,0 +1,45 @@
+"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_registry_exports = {};
+__export(move_registry_exports, {
+  isValidNamedPackage: () => isValidNamedPackage,
+  isValidNamedType: () => isValidNamedType
+});
+module.exports = __toCommonJS(move_registry_exports);
+var import_haneulns = require("./haneulns.js");
+const NAME_PATTERN = /^([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+const VERSION_REGEX = /^\d+$/;
+const MAX_APP_SIZE = 64;
+const NAME_SEPARATOR = "/";
+const isValidNamedPackage = (name) => {
+  const parts = name.split(NAME_SEPARATOR);
+  if (parts.length < 2 || parts.length > 3) return false;
+  const [org, app, version] = parts;
+  if (version !== void 0 && !VERSION_REGEX.test(version)) return false;
+  if (!(0, import_haneulns.isValidHaneulNSName)(org)) return false;
+  return NAME_PATTERN.test(app) && app.length < MAX_APP_SIZE;
+};
+const isValidNamedType = (type) => {
+  const splitType = type.split(/::|<|>|,/);
+  for (const t of splitType) {
+    if (t.includes(NAME_SEPARATOR) && !isValidNamedPackage(t)) return false;
+  }
+  return true;
+};
+//# sourceMappingURL=move-registry.js.map

package/dist/cjs/utils/move-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/move-registry.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { isValidHaneulNSName } from './haneulns.js';\n\n/** The pattern to find an optionally versioned name */\nconst NAME_PATTERN = /^([a-z0-9]+(?:-[a-z0-9]+)*)$/;\n/** The pattern for a valid version number */\nconst VERSION_REGEX = /^\\d+$/;\n/** The maximum size for an app */\nconst MAX_APP_SIZE = 64;\n/** The separator for the name */\nconst NAME_SEPARATOR = '/';\n\nexport const isValidNamedPackage = (name: string): boolean => {\n\tconst parts = name.split(NAME_SEPARATOR);\n\t// The name has to have 2 parts (without-version), or 3 parts (with version).\n\tif (parts.length < 2 || parts.length > 3) return false;\n\n\tconst [org, app, version] = parts; // split by {org} {app} {optional version}\n\n\t// If the version exists, it must be a number.\n\tif (version !== undefined && !VERSION_REGEX.test(version)) return false;\n\t// Check if the org is a valid HaneulNS name.\n\tif (!isValidHaneulNSName(org)) return false;\n\n\t// Check if the app is a valid name.\n\treturn NAME_PATTERN.test(app) && app.length < MAX_APP_SIZE;\n};\n\n/**\n * Checks if a type contains valid named packages.\n * This DOES NOT check if the type is a valid Move type.\n */\nexport const isValidNamedType = (type: string): boolean => {\n\t// split our type by all possible type delimeters.\n\tconst splitType = type.split(/::|<|>|,/);\n\tfor (const t of splitType) {\n\t\tif (t.includes(NAME_SEPARATOR) && !isValidNamedPackage(t)) return false;\n\t}\n\t// TODO: Add `isValidStructTag` check once it's introduced.\n\treturn true;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,sBAAoC;AAGpC,MAAM,eAAe;AAErB,MAAM,gBAAgB;AAEtB,MAAM,eAAe;AAErB,MAAM,iBAAiB;AAEhB,MAAM,sBAAsB,CAAC,SAA0B;AAC7D,QAAM,QAAQ,KAAK,MAAM,cAAc;AAEvC,MAAI,MAAM,SAAS,KAAK,MAAM,SAAS,EAAG,QAAO;AAEjD,QAAM,CAAC,KAAK,KAAK,OAAO,IAAI;AAG5B,MAAI,YAAY,UAAa,CAAC,cAAc,KAAK,OAAO,EAAG,QAAO;AAElE,MAAI,KAAC,qCAAoB,GAAG,EAAG,QAAO;AAGtC,SAAO,aAAa,KAAK,GAAG,KAAK,IAAI,SAAS;AAC/C;AAMO,MAAM,mBAAmB,CAAC,SAA0B;AAE1D,QAAM,YAAY,KAAK,MAAM,UAAU;AACvC,aAAW,KAAK,WAAW;AAC1B,QAAI,EAAE,SAAS,cAAc,KAAK,CAAC,oBAAoB,CAAC,EAAG,QAAO;AAAA,EACnE;AAEA,SAAO;AACR;",
+  "names": []
+}

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

@@ -0,0 +1 @@
+export { verifySignature, verifyPersonalMessageSignature, verifyTransactionSignature, publicKeyFromRawBytes, publicKeyFromSuiBytes, } from './verify.js';

package/dist/cjs/verify/index.js

@@ -0,0 +1,29 @@
+"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 verify_exports = {};
+__export(verify_exports, {
+  publicKeyFromRawBytes: () => import_verify.publicKeyFromRawBytes,
+  publicKeyFromSuiBytes: () => import_verify.publicKeyFromSuiBytes,
+  verifyPersonalMessageSignature: () => import_verify.verifyPersonalMessageSignature,
+  verifySignature: () => import_verify.verifySignature,
+  verifyTransactionSignature: () => import_verify.verifyTransactionSignature
+});
+module.exports = __toCommonJS(verify_exports);
+var import_verify = require("./verify.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/verify/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/verify/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n// eslint-disable-next-line import/no-cycle\nexport {\n\tverifySignature,\n\tverifyPersonalMessageSignature,\n\tverifyTransactionSignature,\n\tpublicKeyFromRawBytes,\n\tpublicKeyFromSuiBytes,\n} from './verify.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,oBAMO;",
+  "names": []
+}

package/dist/cjs/verify/verify.d.ts

@@ -0,0 +1,21 @@
+import type { PublicKey, SignatureScheme } from '../cryptography/index.js';
+import type { ZkLoginCompatibleClient } from '../zklogin/publickey.js';
+export declare function verifySignature(bytes: Uint8Array, signature: string, options?: {
+    address?: string;
+}): Promise<PublicKey>;
+export declare function verifyPersonalMessageSignature(message: Uint8Array, signature: string, options?: {
+    client?: ZkLoginCompatibleClient;
+    address?: string;
+}): Promise<PublicKey>;
+export declare function verifyTransactionSignature(transaction: Uint8Array, signature: string, options?: {
+    client?: ZkLoginCompatibleClient;
+    address?: string;
+}): Promise<PublicKey>;
+export declare function publicKeyFromRawBytes(signatureScheme: SignatureScheme, bytes: Uint8Array, options?: {
+    client?: ZkLoginCompatibleClient;
+    address?: string;
+}): PublicKey;
+export declare function publicKeyFromSuiBytes(publicKey: string | Uint8Array, options?: {
+    client?: ZkLoginCompatibleClient;
+    address?: string;
+}): PublicKey;

package/dist/cjs/verify/verify.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 verify_exports = {};
+__export(verify_exports, {
+  publicKeyFromRawBytes: () => publicKeyFromRawBytes,
+  publicKeyFromSuiBytes: () => publicKeyFromSuiBytes,
+  verifyPersonalMessageSignature: () => verifyPersonalMessageSignature,
+  verifySignature: () => verifySignature,
+  verifyTransactionSignature: () => verifyTransactionSignature
+});
+module.exports = __toCommonJS(verify_exports);
+var import_bcs = require("@haneullabs/bcs");
+var import_cryptography = require("../cryptography/index.js");
+var import_publickey = require("../keypairs/ed25519/publickey.js");
+var import_publickey2 = require("../keypairs/passkey/publickey.js");
+var import_publickey3 = require("../keypairs/secp256k1/publickey.js");
+var import_publickey4 = require("../keypairs/secp256r1/publickey.js");
+var import_publickey5 = require("../multisig/publickey.js");
+var import_publickey6 = require("../zklogin/publickey.js");
+async function verifySignature(bytes, signature, options) {
+  const parsedSignature = parseSignature(signature);
+  if (!await parsedSignature.publicKey.verify(bytes, parsedSignature.serializedSignature)) {
+    throw new Error(`Signature is not valid for the provided data`);
+  }
+  if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+    throw new Error(`Signature is not valid for the provided address`);
+  }
+  return parsedSignature.publicKey;
+}
+async function verifyPersonalMessageSignature(message, signature, options = {}) {
+  const parsedSignature = parseSignature(signature, options);
+  if (!await parsedSignature.publicKey.verifyPersonalMessage(
+    message,
+    parsedSignature.serializedSignature
+  )) {
+    throw new Error(`Signature is not valid for the provided message`);
+  }
+  if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+    throw new Error(`Signature is not valid for the provided address`);
+  }
+  return parsedSignature.publicKey;
+}
+async function verifyTransactionSignature(transaction, signature, options = {}) {
+  const parsedSignature = parseSignature(signature, options);
+  if (!await parsedSignature.publicKey.verifyTransaction(
+    transaction,
+    parsedSignature.serializedSignature
+  )) {
+    throw new Error(`Signature is not valid for the provided Transaction`);
+  }
+  if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+    throw new Error(`Signature is not valid for the provided address`);
+  }
+  return parsedSignature.publicKey;
+}
+function parseSignature(signature, options = {}) {
+  const parsedSignature = (0, import_cryptography.parseSerializedSignature)(signature);
+  if (parsedSignature.signatureScheme === "MultiSig") {
+    return {
+      ...parsedSignature,
+      publicKey: new import_publickey5.MultiSigPublicKey(parsedSignature.multisig.multisig_pk)
+    };
+  }
+  const publicKey = publicKeyFromRawBytes(
+    parsedSignature.signatureScheme,
+    parsedSignature.publicKey,
+    options
+  );
+  return {
+    ...parsedSignature,
+    publicKey
+  };
+}
+function publicKeyFromRawBytes(signatureScheme, bytes, options = {}) {
+  let publicKey;
+  switch (signatureScheme) {
+    case "ED25519":
+      publicKey = new import_publickey.Ed25519PublicKey(bytes);
+      break;
+    case "Secp256k1":
+      publicKey = new import_publickey3.Secp256k1PublicKey(bytes);
+      break;
+    case "Secp256r1":
+      publicKey = new import_publickey4.Secp256r1PublicKey(bytes);
+      break;
+    case "MultiSig":
+      publicKey = new import_publickey5.MultiSigPublicKey(bytes);
+      break;
+    case "ZkLogin":
+      publicKey = import_publickey6.ZkLoginPublicIdentifier.fromBytes(bytes, options);
+      break;
+    case "Passkey":
+      publicKey = new import_publickey2.PasskeyPublicKey(bytes);
+      break;
+    default:
+      throw new Error(`Unsupported signature scheme ${signatureScheme}`);
+  }
+  if (options.address && publicKey.toHaneulAddress() !== options.address) {
+    throw new Error(`Public key bytes do not match the provided address`);
+  }
+  return publicKey;
+}
+function publicKeyFromSuiBytes(publicKey, options = {}) {
+  const bytes = typeof publicKey === "string" ? (0, import_bcs.fromBase64)(publicKey) : publicKey;
+  const signatureScheme = import_cryptography.SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+  return publicKeyFromRawBytes(signatureScheme, bytes.slice(1), options);
+}
+//# sourceMappingURL=verify.js.map

package/dist/cjs/verify/verify.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/verify/verify.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64 } from '@haneullabs/bcs';\n\nimport type { PublicKey, SignatureFlag, SignatureScheme } from '../cryptography/index.js';\nimport { parseSerializedSignature, SIGNATURE_FLAG_TO_SCHEME } from '../cryptography/index.js';\nimport { Ed25519PublicKey } from '../keypairs/ed25519/publickey.js';\nimport { PasskeyPublicKey } from '../keypairs/passkey/publickey.js';\nimport { Secp256k1PublicKey } from '../keypairs/secp256k1/publickey.js';\nimport { Secp256r1PublicKey } from '../keypairs/secp256r1/publickey.js';\n// eslint-disable-next-line import/no-cycle\nimport { MultiSigPublicKey } from '../multisig/publickey.js';\nimport type { ZkLoginCompatibleClient } from '../zklogin/publickey.js';\nimport { ZkLoginPublicIdentifier } from '../zklogin/publickey.js';\n\nexport async function verifySignature(\n\tbytes: Uint8Array,\n\tsignature: string,\n\toptions?: {\n\t\taddress?: string;\n\t},\n): Promise<PublicKey> {\n\tconst parsedSignature = parseSignature(signature);\n\n\tif (!(await parsedSignature.publicKey.verify(bytes, parsedSignature.serializedSignature))) {\n\t\tthrow new Error(`Signature is not valid for the provided data`);\n\t}\n\n\tif (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {\n\t\tthrow new Error(`Signature is not valid for the provided address`);\n\t}\n\n\treturn parsedSignature.publicKey;\n}\n\nexport async function verifyPersonalMessageSignature(\n\tmessage: Uint8Array,\n\tsignature: string,\n\toptions: { client?: ZkLoginCompatibleClient; address?: string } = {},\n): Promise<PublicKey> {\n\tconst parsedSignature = parseSignature(signature, options);\n\n\tif (\n\t\t!(await parsedSignature.publicKey.verifyPersonalMessage(\n\t\t\tmessage,\n\t\t\tparsedSignature.serializedSignature,\n\t\t))\n\t) {\n\t\tthrow new Error(`Signature is not valid for the provided message`);\n\t}\n\n\tif (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {\n\t\tthrow new Error(`Signature is not valid for the provided address`);\n\t}\n\n\treturn parsedSignature.publicKey;\n}\n\nexport async function verifyTransactionSignature(\n\ttransaction: Uint8Array,\n\tsignature: string,\n\toptions: { client?: ZkLoginCompatibleClient; address?: string } = {},\n): Promise<PublicKey> {\n\tconst parsedSignature = parseSignature(signature, options);\n\n\tif (\n\t\t!(await parsedSignature.publicKey.verifyTransaction(\n\t\t\ttransaction,\n\t\t\tparsedSignature.serializedSignature,\n\t\t))\n\t) {\n\t\tthrow new Error(`Signature is not valid for the provided Transaction`);\n\t}\n\n\tif (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {\n\t\tthrow new Error(`Signature is not valid for the provided address`);\n\t}\n\n\treturn parsedSignature.publicKey;\n}\n\nfunction parseSignature(signature: string, options: { client?: ZkLoginCompatibleClient } = {}) {\n\tconst parsedSignature = parseSerializedSignature(signature);\n\n\tif (parsedSignature.signatureScheme === 'MultiSig') {\n\t\treturn {\n\t\t\t...parsedSignature,\n\t\t\tpublicKey: new MultiSigPublicKey(parsedSignature.multisig.multisig_pk),\n\t\t};\n\t}\n\n\tconst publicKey = publicKeyFromRawBytes(\n\t\tparsedSignature.signatureScheme,\n\t\tparsedSignature.publicKey,\n\t\toptions,\n\t);\n\treturn {\n\t\t...parsedSignature,\n\t\tpublicKey,\n\t};\n}\n\nexport function publicKeyFromRawBytes(\n\tsignatureScheme: SignatureScheme,\n\tbytes: Uint8Array,\n\toptions: { client?: ZkLoginCompatibleClient; address?: string } = {},\n): PublicKey {\n\tlet publicKey: PublicKey;\n\tswitch (signatureScheme) {\n\t\tcase 'ED25519':\n\t\t\tpublicKey = new Ed25519PublicKey(bytes);\n\t\t\tbreak;\n\t\tcase 'Secp256k1':\n\t\t\tpublicKey = new Secp256k1PublicKey(bytes);\n\t\t\tbreak;\n\t\tcase 'Secp256r1':\n\t\t\tpublicKey = new Secp256r1PublicKey(bytes);\n\t\t\tbreak;\n\t\tcase 'MultiSig':\n\t\t\tpublicKey = new MultiSigPublicKey(bytes);\n\t\t\tbreak;\n\t\tcase 'ZkLogin':\n\t\t\tpublicKey = ZkLoginPublicIdentifier.fromBytes(bytes, options);\n\t\t\tbreak;\n\t\tcase 'Passkey':\n\t\t\tpublicKey = new PasskeyPublicKey(bytes);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow new Error(`Unsupported signature scheme ${signatureScheme}`);\n\t}\n\n\tif (options.address && publicKey.toHaneulAddress() !== options.address) {\n\t\tthrow new Error(`Public key bytes do not match the provided address`);\n\t}\n\n\treturn publicKey;\n}\n\nexport function publicKeyFromSuiBytes(\n\tpublicKey: string | Uint8Array,\n\toptions: { client?: ZkLoginCompatibleClient; address?: string } = {},\n) {\n\tconst bytes = typeof publicKey === 'string' ? fromBase64(publicKey) : publicKey;\n\n\tconst signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0] as SignatureFlag];\n\n\treturn publicKeyFromRawBytes(signatureScheme, bytes.slice(1), options);\n}\n"],
+  "mappings": "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",
+  "names": ["import_publickey"]
+}

package/dist/cjs/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_VERSION = "0.1.0";
+export declare const TARGETED_RPC_VERSION = "1.0.0";

package/dist/cjs/version.js

@@ -0,0 +1,27 @@
+"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 version_exports = {};
+__export(version_exports, {
+  PACKAGE_VERSION: () => PACKAGE_VERSION,
+  TARGETED_RPC_VERSION: () => TARGETED_RPC_VERSION
+});
+module.exports = __toCommonJS(version_exports);
+const PACKAGE_VERSION = "0.1.0";
+const TARGETED_RPC_VERSION = "1.0.0";
+//# sourceMappingURL=version.js.map

package/dist/cjs/version.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/version.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n// This file is generated by genversion.mjs. Do not edit it directly.\n\nexport const PACKAGE_VERSION = '0.1.0';\nexport const TARGETED_RPC_VERSION = '1.0.0';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;",
+  "names": []
+}

package/dist/cjs/zklogin/address.d.ts

@@ -0,0 +1,16 @@
+export declare function computeZkLoginAddressFromSeed(addressSeed: bigint, iss: string, 
+/** TODO: This default should be changed in the next major release */
+legacyAddress?: boolean): string;
+export declare const MAX_HEADER_LEN_B64 = 248;
+export declare const MAX_PADDED_UNSIGNED_JWT_LEN: number;
+export declare function lengthChecks(jwt: string): void;
+export declare function jwtToAddress(jwt: string, userSalt: string | bigint, legacyAddress?: boolean): string;
+export interface ComputeZkLoginAddressOptions {
+    claimName: string;
+    claimValue: string;
+    userSalt: string | bigint;
+    iss: string;
+    aud: string;
+    legacyAddress?: boolean;
+}
+export declare function computeZkLoginAddress({ claimName, claimValue, iss, aud, userSalt, legacyAddress, }: ComputeZkLoginAddressOptions): string;

package/dist/cjs/zklogin/address.js

@@ -0,0 +1,87 @@
+"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 address_exports = {};
+__export(address_exports, {
+  MAX_HEADER_LEN_B64: () => MAX_HEADER_LEN_B64,
+  MAX_PADDED_UNSIGNED_JWT_LEN: () => MAX_PADDED_UNSIGNED_JWT_LEN,
+  computeZkLoginAddress: () => computeZkLoginAddress,
+  computeZkLoginAddressFromSeed: () => computeZkLoginAddressFromSeed,
+  jwtToAddress: () => jwtToAddress,
+  lengthChecks: () => lengthChecks
+});
+module.exports = __toCommonJS(address_exports);
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_utils = require("@noble/hashes/utils");
+var import_signature_scheme = require("../cryptography/signature-scheme.js");
+var import_utils2 = require("../utils/index.js");
+var import_jwt_utils = require("./jwt-utils.js");
+var import_utils3 = require("./utils.js");
+function computeZkLoginAddressFromSeed(addressSeed, iss, legacyAddress = true) {
+  const addressSeedBytesBigEndian = legacyAddress ? (0, import_utils3.toBigEndianBytes)(addressSeed, 32) : (0, import_utils3.toPaddedBigEndianBytes)(addressSeed, 32);
+  const addressParamBytes = new TextEncoder().encode((0, import_utils3.normalizeZkLoginIssuer)(iss));
+  const tmp = new Uint8Array(2 + addressSeedBytesBigEndian.length + addressParamBytes.length);
+  tmp.set([import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG.ZkLogin]);
+  tmp.set([addressParamBytes.length], 1);
+  tmp.set(addressParamBytes, 2);
+  tmp.set(addressSeedBytesBigEndian, 2 + addressParamBytes.length);
+  return (0, import_utils2.normalizeHaneulAddress)(
+    (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(tmp, { dkLen: 32 })).slice(0, import_utils2.HANEUL_ADDRESS_LENGTH * 2)
+  );
+}
+const MAX_HEADER_LEN_B64 = 248;
+const MAX_PADDED_UNSIGNED_JWT_LEN = 64 * 25;
+function lengthChecks(jwt) {
+  const [header, payload] = jwt.split(".");
+  if (header.length > MAX_HEADER_LEN_B64) {
+    throw new Error(`Header is too long`);
+  }
+  const L = (header.length + 1 + payload.length) * 8;
+  const K = (512 + 448 - (L % 512 + 1)) % 512;
+  const padded_unsigned_jwt_len = (L + 1 + K + 64) / 8;
+  if (padded_unsigned_jwt_len > MAX_PADDED_UNSIGNED_JWT_LEN) {
+    throw new Error(`JWT is too long`);
+  }
+}
+function jwtToAddress(jwt, userSalt, legacyAddress = false) {
+  lengthChecks(jwt);
+  const decodedJWT = (0, import_jwt_utils.decodeJwt)(jwt);
+  return computeZkLoginAddress({
+    userSalt,
+    claimName: "sub",
+    claimValue: decodedJWT.sub,
+    aud: decodedJWT.aud,
+    iss: decodedJWT.iss,
+    legacyAddress
+  });
+}
+function computeZkLoginAddress({
+  claimName,
+  claimValue,
+  iss,
+  aud,
+  userSalt,
+  legacyAddress = false
+}) {
+  return computeZkLoginAddressFromSeed(
+    (0, import_utils3.genAddressSeed)(userSalt, claimName, claimValue, aud),
+    iss,
+    legacyAddress
+  );
+}
+//# sourceMappingURL=address.js.map

package/dist/cjs/zklogin/address.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/address.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { bytesToHex } from '@noble/hashes/utils';\n\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../cryptography/signature-scheme.js';\nimport { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from '../utils/index.js';\nimport { decodeJwt } from './jwt-utils.js';\nimport {\n\tgenAddressSeed,\n\tnormalizeZkLoginIssuer,\n\ttoBigEndianBytes,\n\ttoPaddedBigEndianBytes,\n} from './utils.js';\n\nexport function computeZkLoginAddressFromSeed(\n\taddressSeed: bigint,\n\tiss: string,\n\t/** TODO: This default should be changed in the next major release */\n\tlegacyAddress = true,\n) {\n\tconst addressSeedBytesBigEndian = legacyAddress\n\t\t? toBigEndianBytes(addressSeed, 32)\n\t\t: toPaddedBigEndianBytes(addressSeed, 32);\n\n\tconst addressParamBytes = new TextEncoder().encode(normalizeZkLoginIssuer(iss));\n\tconst tmp = new Uint8Array(2 + addressSeedBytesBigEndian.length + addressParamBytes.length);\n\n\ttmp.set([SIGNATURE_SCHEME_TO_FLAG.ZkLogin]);\n\ttmp.set([addressParamBytes.length], 1);\n\ttmp.set(addressParamBytes, 2);\n\ttmp.set(addressSeedBytesBigEndian, 2 + addressParamBytes.length);\n\n\treturn normalizeHaneulAddress(\n\t\tbytesToHex(blake2b(tmp, { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2),\n\t);\n}\n\nexport const MAX_HEADER_LEN_B64 = 248;\nexport const MAX_PADDED_UNSIGNED_JWT_LEN = 64 * 25;\n\nexport function lengthChecks(jwt: string) {\n\tconst [header, payload] = jwt.split('.');\n\t/// Is the header small enough\n\tif (header.length > MAX_HEADER_LEN_B64) {\n\t\tthrow new Error(`Header is too long`);\n\t}\n\n\t/// Is the combined length of (header, payload, SHA2 padding) small enough?\n\t// unsigned_jwt = header + '.' + payload;\n\tconst L = (header.length + 1 + payload.length) * 8;\n\tconst K = (512 + 448 - ((L % 512) + 1)) % 512;\n\n\t// The SHA2 padding is 1 followed by K zeros, followed by the length of the message\n\tconst padded_unsigned_jwt_len = (L + 1 + K + 64) / 8;\n\n\t// The padded unsigned JWT must be less than the max_padded_unsigned_jwt_len\n\tif (padded_unsigned_jwt_len > MAX_PADDED_UNSIGNED_JWT_LEN) {\n\t\tthrow new Error(`JWT is too long`);\n\t}\n}\n\nexport function jwtToAddress(jwt: string, userSalt: string | bigint, legacyAddress = false) {\n\tlengthChecks(jwt);\n\n\tconst decodedJWT = decodeJwt(jwt);\n\n\treturn computeZkLoginAddress({\n\t\tuserSalt,\n\t\tclaimName: 'sub',\n\t\tclaimValue: decodedJWT.sub,\n\t\taud: decodedJWT.aud,\n\t\tiss: decodedJWT.iss,\n\t\tlegacyAddress,\n\t});\n}\n\nexport interface ComputeZkLoginAddressOptions {\n\tclaimName: string;\n\tclaimValue: string;\n\tuserSalt: string | bigint;\n\tiss: string;\n\taud: string;\n\tlegacyAddress?: boolean;\n}\n\nexport function computeZkLoginAddress({\n\tclaimName,\n\tclaimValue,\n\tiss,\n\taud,\n\tuserSalt,\n\tlegacyAddress = false,\n}: ComputeZkLoginAddressOptions) {\n\treturn computeZkLoginAddressFromSeed(\n\t\tgenAddressSeed(userSalt, claimName, claimValue, aud),\n\t\tiss,\n\t\tlegacyAddress,\n\t);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,qBAAwB;AACxB,mBAA2B;AAE3B,8BAAyC;AACzC,IAAAA,gBAA8D;AAC9D,uBAA0B;AAC1B,IAAAA,gBAKO;AAEA,SAAS,8BACf,aACA,KAEA,gBAAgB,MACf;AACD,QAAM,4BAA4B,oBAC/B,gCAAiB,aAAa,EAAE,QAChC,sCAAuB,aAAa,EAAE;AAEzC,QAAM,oBAAoB,IAAI,YAAY,EAAE,WAAO,sCAAuB,GAAG,CAAC;AAC9E,QAAM,MAAM,IAAI,WAAW,IAAI,0BAA0B,SAAS,kBAAkB,MAAM;AAE1F,MAAI,IAAI,CAAC,iDAAyB,OAAO,CAAC;AAC1C,MAAI,IAAI,CAAC,kBAAkB,MAAM,GAAG,CAAC;AACrC,MAAI,IAAI,mBAAmB,CAAC;AAC5B,MAAI,IAAI,2BAA2B,IAAI,kBAAkB,MAAM;AAE/D,aAAO;AAAA,QACN,6BAAW,wBAAQ,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,sCAAwB,CAAC;AAAA,EAC3E;AACD;AAEO,MAAM,qBAAqB;AAC3B,MAAM,8BAA8B,KAAK;AAEzC,SAAS,aAAa,KAAa;AACzC,QAAM,CAAC,QAAQ,OAAO,IAAI,IAAI,MAAM,GAAG;AAEvC,MAAI,OAAO,SAAS,oBAAoB;AACvC,UAAM,IAAI,MAAM,oBAAoB;AAAA,EACrC;AAIA,QAAM,KAAK,OAAO,SAAS,IAAI,QAAQ,UAAU;AACjD,QAAM,KAAK,MAAM,OAAQ,IAAI,MAAO,MAAM;AAG1C,QAAM,2BAA2B,IAAI,IAAI,IAAI,MAAM;AAGnD,MAAI,0BAA0B,6BAA6B;AAC1D,UAAM,IAAI,MAAM,iBAAiB;AAAA,EAClC;AACD;AAEO,SAAS,aAAa,KAAa,UAA2B,gBAAgB,OAAO;AAC3F,eAAa,GAAG;AAEhB,QAAM,iBAAa,4BAAU,GAAG;AAEhC,SAAO,sBAAsB;AAAA,IAC5B;AAAA,IACA,WAAW;AAAA,IACX,YAAY,WAAW;AAAA,IACvB,KAAK,WAAW;AAAA,IAChB,KAAK,WAAW;AAAA,IAChB;AAAA,EACD,CAAC;AACF;AAWO,SAAS,sBAAsB;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,gBAAgB;AACjB,GAAiC;AAChC,SAAO;AAAA,QACN,8BAAe,UAAU,WAAW,YAAY,GAAG;AAAA,IACnD;AAAA,IACA;AAAA,EACD;AACD;",
+  "names": ["import_utils"]
+}

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

@@ -0,0 +1,28 @@
+import type { InferBcsInput } from '@haneullabs/bcs';
+export declare const zkLoginSignature: import("@haneullabs/bcs").BcsStruct<{
+    inputs: import("@haneullabs/bcs").BcsStruct<{
+        proofPoints: import("@haneullabs/bcs").BcsStruct<{
+            a: import("@haneullabs/bcs").BcsType<string[], Iterable<string> & {
+                length: number;
+            }, string>;
+            b: import("@haneullabs/bcs").BcsType<string[][], Iterable<Iterable<string> & {
+                length: number;
+            }> & {
+                length: number;
+            }, string>;
+            c: import("@haneullabs/bcs").BcsType<string[], Iterable<string> & {
+                length: number;
+            }, string>;
+        }, string>;
+        issBase64Details: import("@haneullabs/bcs").BcsStruct<{
+            value: import("@haneullabs/bcs").BcsType<string, string, "string">;
+            indexMod4: import("@haneullabs/bcs").BcsType<number, number, "u8">;
+        }, string>;
+        headerBase64: import("@haneullabs/bcs").BcsType<string, string, "string">;
+        addressSeed: import("@haneullabs/bcs").BcsType<string, string, "string">;
+    }, string>;
+    maxEpoch: import("@haneullabs/bcs").BcsType<string, string | number | bigint, "u64">;
+    userSignature: import("@haneullabs/bcs").BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
+}, string>;
+export type ZkLoginSignature = InferBcsInput<typeof zkLoginSignature>;
+export type ZkLoginSignatureInputs = ZkLoginSignature['inputs'];

package/dist/cjs/zklogin/bcs.js

@@ -0,0 +1,42 @@
+"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, {
+  zkLoginSignature: () => zkLoginSignature
+});
+module.exports = __toCommonJS(bcs_exports);
+var import_bcs = require("@haneullabs/bcs");
+const zkLoginSignature = import_bcs.bcs.struct("ZkLoginSignature", {
+  inputs: import_bcs.bcs.struct("ZkLoginSignatureInputs", {
+    proofPoints: import_bcs.bcs.struct("ZkLoginSignatureInputsProofPoints", {
+      a: import_bcs.bcs.vector(import_bcs.bcs.string()),
+      b: import_bcs.bcs.vector(import_bcs.bcs.vector(import_bcs.bcs.string())),
+      c: import_bcs.bcs.vector(import_bcs.bcs.string())
+    }),
+    issBase64Details: import_bcs.bcs.struct("ZkLoginSignatureInputsClaim", {
+      value: import_bcs.bcs.string(),
+      indexMod4: import_bcs.bcs.u8()
+    }),
+    headerBase64: import_bcs.bcs.string(),
+    addressSeed: import_bcs.bcs.string()
+  }),
+  maxEpoch: import_bcs.bcs.u64(),
+  userSignature: import_bcs.bcs.byteVector()
+});
+//# sourceMappingURL=bcs.js.map

package/dist/cjs/zklogin/bcs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/bcs.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { InferBcsInput } from '@haneullabs/bcs';\nimport { bcs } from '@haneullabs/bcs';\n\nexport const zkLoginSignature = bcs.struct('ZkLoginSignature', {\n\tinputs: bcs.struct('ZkLoginSignatureInputs', {\n\t\tproofPoints: bcs.struct('ZkLoginSignatureInputsProofPoints', {\n\t\t\ta: bcs.vector(bcs.string()),\n\t\t\tb: bcs.vector(bcs.vector(bcs.string())),\n\t\t\tc: bcs.vector(bcs.string()),\n\t\t}),\n\t\tissBase64Details: bcs.struct('ZkLoginSignatureInputsClaim', {\n\t\t\tvalue: bcs.string(),\n\t\t\tindexMod4: bcs.u8(),\n\t\t}),\n\t\theaderBase64: bcs.string(),\n\t\taddressSeed: bcs.string(),\n\t}),\n\tmaxEpoch: bcs.u64(),\n\tuserSignature: bcs.byteVector(),\n});\n\nexport type ZkLoginSignature = InferBcsInput<typeof zkLoginSignature>;\nexport type ZkLoginSignatureInputs = ZkLoginSignature['inputs'];\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,iBAAoB;AAEb,MAAM,mBAAmB,eAAI,OAAO,oBAAoB;AAAA,EAC9D,QAAQ,eAAI,OAAO,0BAA0B;AAAA,IAC5C,aAAa,eAAI,OAAO,qCAAqC;AAAA,MAC5D,GAAG,eAAI,OAAO,eAAI,OAAO,CAAC;AAAA,MAC1B,GAAG,eAAI,OAAO,eAAI,OAAO,eAAI,OAAO,CAAC,CAAC;AAAA,MACtC,GAAG,eAAI,OAAO,eAAI,OAAO,CAAC;AAAA,IAC3B,CAAC;AAAA,IACD,kBAAkB,eAAI,OAAO,+BAA+B;AAAA,MAC3D,OAAO,eAAI,OAAO;AAAA,MAClB,WAAW,eAAI,GAAG;AAAA,IACnB,CAAC;AAAA,IACD,cAAc,eAAI,OAAO;AAAA,IACzB,aAAa,eAAI,OAAO;AAAA,EACzB,CAAC;AAAA,EACD,UAAU,eAAI,IAAI;AAAA,EAClB,eAAe,eAAI,WAAW;AAC/B,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,9 @@
+export { getZkLoginSignature, parseZkLoginSignature } from './signature.js';
+export { toBigEndianBytes, toPaddedBigEndianBytes, hashASCIIStrToField, genAddressSeed, getExtendedEphemeralPublicKey, } from './utils.js';
+export { computeZkLoginAddressFromSeed, computeZkLoginAddress, jwtToAddress } from './address.js';
+export type { ComputeZkLoginAddressOptions } from './address.js';
+export { toZkLoginPublicIdentifier, ZkLoginPublicIdentifier, type ZkLoginCompatibleClient, } from './publickey.js';
+export type { ZkLoginSignatureInputs } from './bcs.js';
+export { poseidonHash } from './poseidon.js';
+export { generateNonce, generateRandomness } from './nonce.js';
+export { decodeJwt } from './jwt-utils.js';