@haneullabs/haneul 0.1.0

package/dist/esm/utils/haneul-types.js

@@ -0,0 +1,71 @@
+import { fromBase58, splitGenericParameters } from "@haneullabs/bcs";
+import { isValidNamedPackage } from "./move-registry.js";
+const TX_DIGEST_LENGTH = 32;
+function isValidTransactionDigest(value) {
+  try {
+    const buffer = fromBase58(value);
+    return buffer.length === TX_DIGEST_LENGTH;
+  } catch {
+    return false;
+  }
+}
+const HANEUL_ADDRESS_LENGTH = 32;
+function isValidHaneulAddress(value) {
+  return isHex(value) && getHexByteLength(value) === HANEUL_ADDRESS_LENGTH;
+}
+function isValidHaneulObjectId(value) {
+  return isValidHaneulAddress(value);
+}
+function parseTypeTag(type) {
+  if (!type.includes("::")) return type;
+  return parseStructTag(type);
+}
+function parseStructTag(type) {
+  const [address, module] = type.split("::");
+  const isMvrPackage = isValidNamedPackage(address);
+  const rest = type.slice(address.length + module.length + 4);
+  const name = rest.includes("<") ? rest.slice(0, rest.indexOf("<")) : rest;
+  const typeParams = rest.includes("<") ? splitGenericParameters(rest.slice(rest.indexOf("<") + 1, rest.lastIndexOf(">"))).map(
+    (typeParam) => parseTypeTag(typeParam.trim())
+  ) : [];
+  return {
+    address: isMvrPackage ? address : normalizeHaneulAddress(address),
+    module,
+    name,
+    typeParams
+  };
+}
+function normalizeStructTag(type) {
+  const { address, module, name, typeParams } = typeof type === "string" ? parseStructTag(type) : type;
+  const formattedTypeParams = typeParams?.length > 0 ? `<${typeParams.map(
+    (typeParam) => typeof typeParam === "string" ? typeParam : normalizeStructTag(typeParam)
+  ).join(",")}>` : "";
+  return `${address}::${module}::${name}${formattedTypeParams}`;
+}
+function normalizeHaneulAddress(value, forceAdd0x = false) {
+  let address = value.toLowerCase();
+  if (!forceAdd0x && address.startsWith("0x")) {
+    address = address.slice(2);
+  }
+  return `0x${address.padStart(HANEUL_ADDRESS_LENGTH * 2, "0")}`;
+}
+function normalizeHaneulObjectId(value, forceAdd0x = false) {
+  return normalizeHaneulAddress(value, forceAdd0x);
+}
+function isHex(value) {
+  return /^(0x|0X)?[a-fA-F0-9]+$/.test(value) && value.length % 2 === 0;
+}
+function getHexByteLength(value) {
+  return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;
+}
+export {
+  HANEUL_ADDRESS_LENGTH,
+  isValidHaneulAddress,
+  isValidHaneulObjectId,
+  isValidTransactionDigest,
+  normalizeHaneulAddress,
+  normalizeHaneulObjectId,
+  normalizeStructTag,
+  parseStructTag
+};
+//# sourceMappingURL=haneul-types.js.map

package/dist/esm/utils/haneul-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/haneul-types.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase58, splitGenericParameters } from '@haneullabs/bcs';\n\nimport { isValidNamedPackage } from './move-registry.js';\n\nconst TX_DIGEST_LENGTH = 32;\n\n/** Returns whether the tx digest is valid based on the serialization format */\nexport function isValidTransactionDigest(value: string): value is string {\n\ttry {\n\t\tconst buffer = fromBase58(value);\n\t\treturn buffer.length === TX_DIGEST_LENGTH;\n\t} catch {\n\t\treturn false;\n\t}\n}\n\n// TODO - can we automatically sync this with rust length definition?\n// Source of truth is\n// https://github.com/GeunhwaJeong/haneul/blob/acb2b97ae21f47600e05b0d28127d88d0725561d/crate./haneul-types/src/base_types.rs#L67\n// which uses the Move account address length\n// https://github.com/move-language/move/blob/67ec40dc50c66c34fd73512fcc412f3b68d67235/language/move-core/types/src/account_address.rs#L23 .\n\nexport const HANEUL_ADDRESS_LENGTH = 32;\nexport function isValidHaneulAddress(value: string): value is string {\n\treturn isHex(value) && getHexByteLength(value) === HANEUL_ADDRESS_LENGTH;\n}\n\nexport function isValidHaneulObjectId(value: string): boolean {\n\treturn isValidHaneulAddress(value);\n}\n\nexport type StructTag = {\n\taddress: string;\n\tmodule: string;\n\tname: string;\n\ttypeParams: (string | StructTag)[];\n};\n\nfunction parseTypeTag(type: string): string | StructTag {\n\tif (!type.includes('::')) return type;\n\n\treturn parseStructTag(type);\n}\n\nexport function parseStructTag(type: string): StructTag {\n\tconst [address, module] = type.split('::');\n\n\tconst isMvrPackage = isValidNamedPackage(address);\n\n\tconst rest = type.slice(address.length + module.length + 4);\n\tconst name = rest.includes('<') ? rest.slice(0, rest.indexOf('<')) : rest;\n\tconst typeParams = rest.includes('<')\n\t\t? splitGenericParameters(rest.slice(rest.indexOf('<') + 1, rest.lastIndexOf('>'))).map(\n\t\t\t\t(typeParam) => parseTypeTag(typeParam.trim()),\n\t\t\t)\n\t\t: [];\n\n\treturn {\n\t\taddress: isMvrPackage ? address : normalizeHaneulAddress(address),\n\t\tmodule,\n\t\tname,\n\t\ttypeParams,\n\t};\n}\n\nexport function normalizeStructTag(type: string | StructTag): string {\n\tconst { address, module, name, typeParams } =\n\t\ttypeof type === 'string' ? parseStructTag(type) : type;\n\n\tconst formattedTypeParams =\n\t\ttypeParams?.length > 0\n\t\t\t? `<${typeParams\n\t\t\t\t\t.map((typeParam) =>\n\t\t\t\t\t\ttypeof typeParam === 'string' ? typeParam : normalizeStructTag(typeParam),\n\t\t\t\t\t)\n\t\t\t\t\t.join(',')}>`\n\t\t\t: '';\n\n\treturn `${address}::${module}::${name}${formattedTypeParams}`;\n}\n\n/**\n * Perform the following operations:\n * 1. Make the address lower case\n * 2. Prepend `0x` if the string does not start with `0x`.\n * 3. Add more zeros if the length of the address(excluding `0x`) is less than `HANEUL_ADDRESS_LENGTH`\n *\n * WARNING: if the address value itself starts with `0x`, e.g., `0x0x`, the default behavior\n * is to treat the first `0x` not as part of the address. The default behavior can be overridden by\n * setting `forceAdd0x` to true\n *\n */\nexport function normalizeHaneulAddress(value: string, forceAdd0x: boolean = false): string {\n\tlet address = value.toLowerCase();\n\tif (!forceAdd0x && address.startsWith('0x')) {\n\t\taddress = address.slice(2);\n\t}\n\treturn `0x${address.padStart(HANEUL_ADDRESS_LENGTH * 2, '0')}`;\n}\n\nexport function normalizeHaneulObjectId(value: string, forceAdd0x: boolean = false): string {\n\treturn normalizeHaneulAddress(value, forceAdd0x);\n}\n\nfunction isHex(value: string): boolean {\n\treturn /^(0x|0X)?[a-fA-F0-9]+$/.test(value) && value.length % 2 === 0;\n}\n\nfunction getHexByteLength(value: string): number {\n\treturn /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;\n}\n"],
+  "mappings": "AAGA,SAAS,YAAY,8BAA8B;AAEnD,SAAS,2BAA2B;AAEpC,MAAM,mBAAmB;AAGlB,SAAS,yBAAyB,OAAgC;AACxE,MAAI;AACH,UAAM,SAAS,WAAW,KAAK;AAC/B,WAAO,OAAO,WAAW;AAAA,EAC1B,QAAQ;AACP,WAAO;AAAA,EACR;AACD;AAQO,MAAM,wBAAwB;AAC9B,SAAS,qBAAqB,OAAgC;AACpE,SAAO,MAAM,KAAK,KAAK,iBAAiB,KAAK,MAAM;AACpD;AAEO,SAAS,sBAAsB,OAAwB;AAC7D,SAAO,qBAAqB,KAAK;AAClC;AASA,SAAS,aAAa,MAAkC;AACvD,MAAI,CAAC,KAAK,SAAS,IAAI,EAAG,QAAO;AAEjC,SAAO,eAAe,IAAI;AAC3B;AAEO,SAAS,eAAe,MAAyB;AACvD,QAAM,CAAC,SAAS,MAAM,IAAI,KAAK,MAAM,IAAI;AAEzC,QAAM,eAAe,oBAAoB,OAAO;AAEhD,QAAM,OAAO,KAAK,MAAM,QAAQ,SAAS,OAAO,SAAS,CAAC;AAC1D,QAAM,OAAO,KAAK,SAAS,GAAG,IAAI,KAAK,MAAM,GAAG,KAAK,QAAQ,GAAG,CAAC,IAAI;AACrE,QAAM,aAAa,KAAK,SAAS,GAAG,IACjC,uBAAuB,KAAK,MAAM,KAAK,QAAQ,GAAG,IAAI,GAAG,KAAK,YAAY,GAAG,CAAC,CAAC,EAAE;AAAA,IACjF,CAAC,cAAc,aAAa,UAAU,KAAK,CAAC;AAAA,EAC7C,IACC,CAAC;AAEJ,SAAO;AAAA,IACN,SAAS,eAAe,UAAU,uBAAuB,OAAO;AAAA,IAChE;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;AAEO,SAAS,mBAAmB,MAAkC;AACpE,QAAM,EAAE,SAAS,QAAQ,MAAM,WAAW,IACzC,OAAO,SAAS,WAAW,eAAe,IAAI,IAAI;AAEnD,QAAM,sBACL,YAAY,SAAS,IAClB,IAAI,WACH;AAAA,IAAI,CAAC,cACL,OAAO,cAAc,WAAW,YAAY,mBAAmB,SAAS;AAAA,EACzE,EACC,KAAK,GAAG,CAAC,MACV;AAEJ,SAAO,GAAG,OAAO,KAAK,MAAM,KAAK,IAAI,GAAG,mBAAmB;AAC5D;AAaO,SAAS,uBAAuB,OAAe,aAAsB,OAAe;AAC1F,MAAI,UAAU,MAAM,YAAY;AAChC,MAAI,CAAC,cAAc,QAAQ,WAAW,IAAI,GAAG;AAC5C,cAAU,QAAQ,MAAM,CAAC;AAAA,EAC1B;AACA,SAAO,KAAK,QAAQ,SAAS,wBAAwB,GAAG,GAAG,CAAC;AAC7D;AAEO,SAAS,wBAAwB,OAAe,aAAsB,OAAe;AAC3F,SAAO,uBAAuB,OAAO,UAAU;AAChD;AAEA,SAAS,MAAM,OAAwB;AACtC,SAAO,yBAAyB,KAAK,KAAK,KAAK,MAAM,SAAS,MAAM;AACrE;AAEA,SAAS,iBAAiB,OAAuB;AAChD,SAAO,WAAW,KAAK,KAAK,KAAK,MAAM,SAAS,KAAK,IAAI,MAAM,SAAS;AACzE;",
+  "names": []
+}

package/dist/esm/utils/haneulns.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidHaneulNSName(name: string): boolean;
+export declare function normalizeHaneulNSName(name: string, format?: 'at' | 'dot'): string;

package/dist/esm/utils/haneulns.js

@@ -0,0 +1,37 @@
+const HANEUL_NS_NAME_REGEX = /^(?!.*(^(?!@)|[-.@])($|[-.@]))(?:[a-z0-9-]{0,63}(?:\.[a-z0-9-]{0,63})*)?@[a-z0-9-]{0,63}$/i;
+const HANEUL_NS_DOMAIN_REGEX = /^(?!.*(^|[-.])($|[-.]))(?:[a-z0-9-]{0,63}\.)+haneul$/i;
+const MAX_HANEUL_NS_NAME_LENGTH = 235;
+function isValidHaneulNSName(name) {
+  if (name.length > MAX_HANEUL_NS_NAME_LENGTH) {
+    return false;
+  }
+  if (name.includes("@")) {
+    return HANEUL_NS_NAME_REGEX.test(name);
+  }
+  return HANEUL_NS_DOMAIN_REGEX.test(name);
+}
+function normalizeHaneulNSName(name, format = "at") {
+  const lowerCase = name.toLowerCase();
+  let parts;
+  if (lowerCase.includes("@")) {
+    if (!HANEUL_NS_NAME_REGEX.test(lowerCase)) {
+      throw new Error(`Invalid HaneulNS name ${name}`);
+    }
+    const [labels, domain] = lowerCase.split("@");
+    parts = [...labels ? labels.split(".") : [], domain];
+  } else {
+    if (!HANEUL_NS_DOMAIN_REGEX.test(lowerCase)) {
+      throw new Error(`Invalid HaneulNS name ${name}`);
+    }
+    parts = lowerCase.split(".").slice(0, -1);
+  }
+  if (format === "dot") {
+    return `${parts.join(".")}.haneul`;
+  }
+  return `${parts.slice(0, -1).join(".")}@${parts[parts.length - 1]}`;
+}
+export {
+  isValidHaneulNSName,
+  normalizeHaneulNSName
+};
+//# sourceMappingURL=haneulns.js.map

package/dist/esm/utils/haneulns.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/haneulns.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nconst HANEUL_NS_NAME_REGEX =\n\t/^(?!.*(^(?!@)|[-.@])($|[-.@]))(?:[a-z0-9-]{0,63}(?:\\.[a-z0-9-]{0,63})*)?@[a-z0-9-]{0,63}$/i;\nconst HANEUL_NS_DOMAIN_REGEX = /^(?!.*(^|[-.])($|[-.]))(?:[a-z0-9-]{0,63}\\.)+haneul$/i;\nconst MAX_HANEUL_NS_NAME_LENGTH = 235;\n\nexport function isValidHaneulNSName(name: string): boolean {\n\tif (name.length > MAX_HANEUL_NS_NAME_LENGTH) {\n\t\treturn false;\n\t}\n\n\tif (name.includes('@')) {\n\t\treturn HANEUL_NS_NAME_REGEX.test(name);\n\t}\n\n\treturn HANEUL_NS_DOMAIN_REGEX.test(name);\n}\n\nexport function normalizeHaneulNSName(name: string, format: 'at' | 'dot' = 'at'): string {\n\tconst lowerCase = name.toLowerCase();\n\tlet parts;\n\n\tif (lowerCase.includes('@')) {\n\t\tif (!HANEUL_NS_NAME_REGEX.test(lowerCase)) {\n\t\t\tthrow new Error(`Invalid HaneulNS name ${name}`);\n\t\t}\n\t\tconst [labels, domain] = lowerCase.split('@');\n\t\tparts = [...(labels ? labels.split('.') : []), domain];\n\t} else {\n\t\tif (!HANEUL_NS_DOMAIN_REGEX.test(lowerCase)) {\n\t\t\tthrow new Error(`Invalid HaneulNS name ${name}`);\n\t\t}\n\t\tparts = lowerCase.split('.').slice(0, -1);\n\t}\n\n\tif (format === 'dot') {\n\t\treturn `${parts.join('.')}.haneul`;\n\t}\n\n\treturn `${parts.slice(0, -1).join('.')}@${parts[parts.length - 1]}`;\n}\n"],
+  "mappings": "AAGA,MAAM,uBACL;AACD,MAAM,yBAAyB;AAC/B,MAAM,4BAA4B;AAE3B,SAAS,oBAAoB,MAAuB;AAC1D,MAAI,KAAK,SAAS,2BAA2B;AAC5C,WAAO;AAAA,EACR;AAEA,MAAI,KAAK,SAAS,GAAG,GAAG;AACvB,WAAO,qBAAqB,KAAK,IAAI;AAAA,EACtC;AAEA,SAAO,uBAAuB,KAAK,IAAI;AACxC;AAEO,SAAS,sBAAsB,MAAc,SAAuB,MAAc;AACxF,QAAM,YAAY,KAAK,YAAY;AACnC,MAAI;AAEJ,MAAI,UAAU,SAAS,GAAG,GAAG;AAC5B,QAAI,CAAC,qBAAqB,KAAK,SAAS,GAAG;AAC1C,YAAM,IAAI,MAAM,yBAAyB,IAAI,EAAE;AAAA,IAChD;AACA,UAAM,CAAC,QAAQ,MAAM,IAAI,UAAU,MAAM,GAAG;AAC5C,YAAQ,CAAC,GAAI,SAAS,OAAO,MAAM,GAAG,IAAI,CAAC,GAAI,MAAM;AAAA,EACtD,OAAO;AACN,QAAI,CAAC,uBAAuB,KAAK,SAAS,GAAG;AAC5C,YAAM,IAAI,MAAM,yBAAyB,IAAI,EAAE;AAAA,IAChD;AACA,YAAQ,UAAU,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE;AAAA,EACzC;AAEA,MAAI,WAAW,OAAO;AACrB,WAAO,GAAG,MAAM,KAAK,GAAG,CAAC;AAAA,EAC1B;AAEA,SAAO,GAAG,MAAM,MAAM,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC,IAAI,MAAM,MAAM,SAAS,CAAC,CAAC;AAClE;",
+  "names": []
+}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,9 @@
+export { formatAddress, formatDigest } from './format.js';
+export { isValidHaneulAddress, isValidHaneulObjectId, isValidTransactionDigest, normalizeStructTag, normalizeHaneulAddress, normalizeHaneulObjectId, parseStructTag, HANEUL_ADDRESS_LENGTH, } from './haneul-types.js';
+export { fromB64, toB64, fromHEX, toHex, toHEX, fromHex, fromBase64, toBase64, fromBase58, toBase58, } from '@haneullabs/bcs';
+export { isValidHaneulNSName, normalizeHaneulNSName } from './haneulns.js';
+export { HANEUL_DECIMALS, GEUNHWA_PER_HANEUL, MOVE_STDLIB_ADDRESS, HANEUL_FRAMEWORK_ADDRESS, HANEUL_SYSTEM_ADDRESS, HANEUL_CLOCK_OBJECT_ID, HANEUL_SYSTEM_MODULE_NAME, HANEUL_TYPE_ARG, HANEUL_SYSTEM_STATE_OBJECT_ID, HANEUL_RANDOM_OBJECT_ID, } from './constants.js';
+export { isValidNamedPackage, isValidNamedType } from './move-registry.js';
+export { deriveDynamicFieldID } from './dynamic-fields.js';
+export { deriveObjectID } from './derived-objects.js';
+export { normalizeTypeTag } from '../bcs/type-tag-serializer.js';

package/dist/esm/utils/index.js

@@ -0,0 +1,80 @@
+import { formatAddress, formatDigest } from "./format.js";
+import {
+  isValidHaneulAddress,
+  isValidHaneulObjectId,
+  isValidTransactionDigest,
+  normalizeStructTag,
+  normalizeHaneulAddress,
+  normalizeHaneulObjectId,
+  parseStructTag,
+  HANEUL_ADDRESS_LENGTH
+} from "./haneul-types.js";
+import {
+  fromB64,
+  toB64,
+  fromHEX,
+  toHex,
+  toHEX,
+  fromHex,
+  fromBase64,
+  toBase64,
+  fromBase58,
+  toBase58
+} from "@haneullabs/bcs";
+import { isValidHaneulNSName, normalizeHaneulNSName } from "./haneulns.js";
+import {
+  HANEUL_DECIMALS,
+  GEUNHWA_PER_HANEUL,
+  MOVE_STDLIB_ADDRESS,
+  HANEUL_FRAMEWORK_ADDRESS,
+  HANEUL_SYSTEM_ADDRESS,
+  HANEUL_CLOCK_OBJECT_ID,
+  HANEUL_SYSTEM_MODULE_NAME,
+  HANEUL_TYPE_ARG,
+  HANEUL_SYSTEM_STATE_OBJECT_ID,
+  HANEUL_RANDOM_OBJECT_ID
+} from "./constants.js";
+import { isValidNamedPackage, isValidNamedType } from "./move-registry.js";
+import { deriveDynamicFieldID } from "./dynamic-fields.js";
+import { deriveObjectID } from "./derived-objects.js";
+import { normalizeTypeTag } from "../bcs/type-tag-serializer.js";
+export {
+  GEUNHWA_PER_HANEUL,
+  HANEUL_ADDRESS_LENGTH,
+  HANEUL_CLOCK_OBJECT_ID,
+  HANEUL_DECIMALS,
+  HANEUL_FRAMEWORK_ADDRESS,
+  HANEUL_RANDOM_OBJECT_ID,
+  HANEUL_SYSTEM_ADDRESS,
+  HANEUL_SYSTEM_MODULE_NAME,
+  HANEUL_SYSTEM_STATE_OBJECT_ID,
+  HANEUL_TYPE_ARG,
+  MOVE_STDLIB_ADDRESS,
+  deriveDynamicFieldID,
+  deriveObjectID,
+  formatAddress,
+  formatDigest,
+  fromB64,
+  fromBase58,
+  fromBase64,
+  fromHEX,
+  fromHex,
+  isValidHaneulAddress,
+  isValidHaneulNSName,
+  isValidHaneulObjectId,
+  isValidNamedPackage,
+  isValidNamedType,
+  isValidTransactionDigest,
+  normalizeHaneulAddress,
+  normalizeHaneulNSName,
+  normalizeHaneulObjectId,
+  normalizeStructTag,
+  normalizeTypeTag,
+  parseStructTag,
+  toB64,
+  toBase58,
+  toBase64,
+  toHEX,
+  toHex
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/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": "AAGA,SAAS,eAAe,oBAAoB;AAC5C;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;AAEP;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;AACP,SAAS,qBAAqB,6BAA6B;AAE3D;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;AAEP,SAAS,qBAAqB,wBAAwB;AAEtD,SAAS,4BAA4B;AAErC,SAAS,sBAAsB;AAC/B,SAAS,wBAAwB;",
+  "names": []
+}

package/dist/esm/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/esm/utils/move-registry.js

@@ -0,0 +1,25 @@
+import { isValidHaneulNSName } from "./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 (!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;
+};
+export {
+  isValidNamedPackage,
+  isValidNamedType
+};
+//# sourceMappingURL=move-registry.js.map

package/dist/esm/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": "AAGA,SAAS,2BAA2B;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,CAAC,oBAAoB,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/esm/verify/index.d.ts

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

package/dist/esm/verify/index.js

@@ -0,0 +1,15 @@
+import {
+  verifySignature,
+  verifyPersonalMessageSignature,
+  verifyTransactionSignature,
+  publicKeyFromRawBytes,
+  publicKeyFromSuiBytes
+} from "./verify.js";
+export {
+  publicKeyFromRawBytes,
+  publicKeyFromSuiBytes,
+  verifyPersonalMessageSignature,
+  verifySignature,
+  verifyTransactionSignature
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/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": "AAIA;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;",
+  "names": []
+}

package/dist/esm/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/esm/verify/verify.js

@@ -0,0 +1,104 @@
+import { fromBase64 } from "@haneullabs/bcs";
+import { parseSerializedSignature, SIGNATURE_FLAG_TO_SCHEME } from "../cryptography/index.js";
+import { Ed25519PublicKey } from "../keypairs/ed25519/publickey.js";
+import { PasskeyPublicKey } from "../keypairs/passkey/publickey.js";
+import { Secp256k1PublicKey } from "../keypairs/secp256k1/publickey.js";
+import { Secp256r1PublicKey } from "../keypairs/secp256r1/publickey.js";
+import { MultiSigPublicKey } from "../multisig/publickey.js";
+import { ZkLoginPublicIdentifier } from "../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 = parseSerializedSignature(signature);
+  if (parsedSignature.signatureScheme === "MultiSig") {
+    return {
+      ...parsedSignature,
+      publicKey: new 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 Ed25519PublicKey(bytes);
+      break;
+    case "Secp256k1":
+      publicKey = new Secp256k1PublicKey(bytes);
+      break;
+    case "Secp256r1":
+      publicKey = new Secp256r1PublicKey(bytes);
+      break;
+    case "MultiSig":
+      publicKey = new MultiSigPublicKey(bytes);
+      break;
+    case "ZkLogin":
+      publicKey = ZkLoginPublicIdentifier.fromBytes(bytes, options);
+      break;
+    case "Passkey":
+      publicKey = new 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" ? fromBase64(publicKey) : publicKey;
+  const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+  return publicKeyFromRawBytes(signatureScheme, bytes.slice(1), options);
+}
+export {
+  publicKeyFromRawBytes,
+  publicKeyFromSuiBytes,
+  verifyPersonalMessageSignature,
+  verifySignature,
+  verifyTransactionSignature
+};
+//# sourceMappingURL=verify.js.map

package/dist/esm/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": []
+}

package/dist/esm/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/esm/version.js

@@ -0,0 +1,7 @@
+const PACKAGE_VERSION = "0.1.0";
+const TARGETED_RPC_VERSION = "1.0.0";
+export {
+  PACKAGE_VERSION,
+  TARGETED_RPC_VERSION
+};
+//# sourceMappingURL=version.js.map

package/dist/esm/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": "AAKO,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;",
+  "names": []
+}

package/dist/esm/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/esm/zklogin/address.js

@@ -0,0 +1,72 @@
+import { blake2b } from "@noble/hashes/blake2b";
+import { bytesToHex } from "@noble/hashes/utils";
+import { SIGNATURE_SCHEME_TO_FLAG } from "../cryptography/signature-scheme.js";
+import { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from "../utils/index.js";
+import { decodeJwt } from "./jwt-utils.js";
+import {
+  genAddressSeed,
+  normalizeZkLoginIssuer,
+  toBigEndianBytes,
+  toPaddedBigEndianBytes
+} from "./utils.js";
+function computeZkLoginAddressFromSeed(addressSeed, iss, legacyAddress = true) {
+  const addressSeedBytesBigEndian = legacyAddress ? toBigEndianBytes(addressSeed, 32) : toPaddedBigEndianBytes(addressSeed, 32);
+  const addressParamBytes = new TextEncoder().encode(normalizeZkLoginIssuer(iss));
+  const tmp = new Uint8Array(2 + addressSeedBytesBigEndian.length + addressParamBytes.length);
+  tmp.set([SIGNATURE_SCHEME_TO_FLAG.ZkLogin]);
+  tmp.set([addressParamBytes.length], 1);
+  tmp.set(addressParamBytes, 2);
+  tmp.set(addressSeedBytesBigEndian, 2 + addressParamBytes.length);
+  return normalizeHaneulAddress(
+    bytesToHex(blake2b(tmp, { dkLen: 32 })).slice(0, 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 = 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(
+    genAddressSeed(userSalt, claimName, claimValue, aud),
+    iss,
+    legacyAddress
+  );
+}
+export {
+  MAX_HEADER_LEN_B64,
+  MAX_PADDED_UNSIGNED_JWT_LEN,
+  computeZkLoginAddress,
+  computeZkLoginAddressFromSeed,
+  jwtToAddress,
+  lengthChecks
+};
+//# sourceMappingURL=address.js.map

package/dist/esm/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": "AAGA,SAAS,eAAe;AACxB,SAAS,kBAAkB;AAE3B,SAAS,gCAAgC;AACzC,SAAS,wBAAwB,6BAA6B;AAC9D,SAAS,iBAAiB;AAC1B;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;AAEA,SAAS,8BACf,aACA,KAEA,gBAAgB,MACf;AACD,QAAM,4BAA4B,gBAC/B,iBAAiB,aAAa,EAAE,IAChC,uBAAuB,aAAa,EAAE;AAEzC,QAAM,oBAAoB,IAAI,YAAY,EAAE,OAAO,uBAAuB,GAAG,CAAC;AAC9E,QAAM,MAAM,IAAI,WAAW,IAAI,0BAA0B,SAAS,kBAAkB,MAAM;AAE1F,MAAI,IAAI,CAAC,yBAAyB,OAAO,CAAC;AAC1C,MAAI,IAAI,CAAC,kBAAkB,MAAM,GAAG,CAAC;AACrC,MAAI,IAAI,mBAAmB,CAAC;AAC5B,MAAI,IAAI,2BAA2B,IAAI,kBAAkB,MAAM;AAE/D,SAAO;AAAA,IACN,WAAW,QAAQ,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,wBAAwB,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,aAAa,UAAU,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,IACN,eAAe,UAAU,WAAW,YAAY,GAAG;AAAA,IACnD;AAAA,IACA;AAAA,EACD;AACD;",
+  "names": []
+}

package/dist/esm/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'];