@haneullabs/haneul 0.1.0

package/dist/cjs/zklogin/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 zklogin_exports = {};
+__export(zklogin_exports, {
+  ZkLoginPublicIdentifier: () => import_publickey.ZkLoginPublicIdentifier,
+  computeZkLoginAddress: () => import_address.computeZkLoginAddress,
+  computeZkLoginAddressFromSeed: () => import_address.computeZkLoginAddressFromSeed,
+  decodeJwt: () => import_jwt_utils.decodeJwt,
+  genAddressSeed: () => import_utils.genAddressSeed,
+  generateNonce: () => import_nonce.generateNonce,
+  generateRandomness: () => import_nonce.generateRandomness,
+  getExtendedEphemeralPublicKey: () => import_utils.getExtendedEphemeralPublicKey,
+  getZkLoginSignature: () => import_signature.getZkLoginSignature,
+  hashASCIIStrToField: () => import_utils.hashASCIIStrToField,
+  jwtToAddress: () => import_address.jwtToAddress,
+  parseZkLoginSignature: () => import_signature.parseZkLoginSignature,
+  poseidonHash: () => import_poseidon.poseidonHash,
+  toBigEndianBytes: () => import_utils.toBigEndianBytes,
+  toPaddedBigEndianBytes: () => import_utils.toPaddedBigEndianBytes,
+  toZkLoginPublicIdentifier: () => import_publickey.toZkLoginPublicIdentifier
+});
+module.exports = __toCommonJS(zklogin_exports);
+var import_signature = require("./signature.js");
+var import_utils = require("./utils.js");
+var import_address = require("./address.js");
+var import_publickey = require("./publickey.js");
+var import_poseidon = require("./poseidon.js");
+var import_nonce = require("./nonce.js");
+var import_jwt_utils = require("./jwt-utils.js");
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport { getZkLoginSignature, parseZkLoginSignature } from './signature.js';\nexport {\n\ttoBigEndianBytes,\n\ttoPaddedBigEndianBytes,\n\thashASCIIStrToField,\n\tgenAddressSeed,\n\tgetExtendedEphemeralPublicKey,\n} from './utils.js';\nexport { computeZkLoginAddressFromSeed, computeZkLoginAddress, jwtToAddress } from './address.js';\nexport type { ComputeZkLoginAddressOptions } from './address.js';\nexport {\n\ttoZkLoginPublicIdentifier,\n\tZkLoginPublicIdentifier,\n\ttype ZkLoginCompatibleClient,\n} from './publickey.js';\nexport type { ZkLoginSignatureInputs } from './bcs.js';\nexport { poseidonHash } from './poseidon.js';\nexport { generateNonce, generateRandomness } from './nonce.js';\nexport { decodeJwt } from './jwt-utils.js';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,uBAA2D;AAC3D,mBAMO;AACP,qBAAmF;AAEnF,uBAIO;AAEP,sBAA6B;AAC7B,mBAAkD;AAClD,uBAA0B;",
+  "names": []
+}

package/dist/cjs/zklogin/jwt-decode.d.ts

@@ -0,0 +1,47 @@
+/** Copied from https://github.com/auth0/jwt-decode/blob/3d372e9875ff673228a9f2d9df74e84690842a9c/lib/index.ts */
+/**
+The MIT License (MIT)
+
+Copyright (c) 2015 Auth0, Inc. <support@auth0.com> (http://auth0.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+export interface JwtDecodeOptions {
+    header?: boolean;
+}
+export interface JwtHeader {
+    typ?: string;
+    alg?: string;
+    kid?: string;
+}
+export interface JwtPayload {
+    iss?: string;
+    sub?: string;
+    aud?: string[] | string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+}
+export declare class InvalidTokenError extends Error {
+}
+export declare function jwtDecode<T = JwtHeader>(token: string, options: JwtDecodeOptions & {
+    header: true;
+}): T;
+export declare function jwtDecode<T = JwtPayload>(token: string, options?: JwtDecodeOptions): T;

package/dist/cjs/zklogin/jwt-decode.js

@@ -0,0 +1,85 @@
+"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 jwt_decode_exports = {};
+__export(jwt_decode_exports, {
+  InvalidTokenError: () => InvalidTokenError,
+  jwtDecode: () => jwtDecode
+});
+module.exports = __toCommonJS(jwt_decode_exports);
+class InvalidTokenError extends Error {
+}
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(
+    atob(str).replace(/(.)/g, (_m, p) => {
+      let code = p.charCodeAt(0).toString(16).toUpperCase();
+      if (code.length < 2) {
+        code = "0" + code;
+      }
+      return "%" + code;
+    })
+  );
+}
+function base64UrlDecode(str) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return b64DecodeUnicode(output);
+  } catch {
+    return atob(output);
+  }
+}
+function jwtDecode(token, options) {
+  if (typeof token !== "string") {
+    throw new InvalidTokenError("Invalid token specified: must be a string");
+  }
+  options || (options = {});
+  const pos = options.header === true ? 0 : 1;
+  const part = token.split(".")[pos];
+  if (typeof part !== "string") {
+    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  }
+  let decoded;
+  try {
+    decoded = base64UrlDecode(part);
+  } catch (e) {
+    throw new InvalidTokenError(
+      `Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`
+    );
+  }
+  try {
+    return JSON.parse(decoded);
+  } catch (e) {
+    throw new InvalidTokenError(
+      `Invalid token specified: invalid json for part #${pos + 1} (${e.message})`
+    );
+  }
+}
+//# sourceMappingURL=jwt-decode.js.map

package/dist/cjs/zklogin/jwt-decode.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/jwt-decode.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n// oxlint-disable check-tag-names\n\n/** Copied from https://github.com/auth0/jwt-decode/blob/3d372e9875ff673228a9f2d9df74e84690842a9c/lib/index.ts */\n\n/**\nThe MIT License (MIT)\n\nCopyright (c) 2015 Auth0, Inc. <support@auth0.com> (http://auth0.com)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n */\n\nexport interface JwtDecodeOptions {\n\theader?: boolean;\n}\n\nexport interface JwtHeader {\n\ttyp?: string;\n\talg?: string;\n\tkid?: string;\n}\n\nexport interface JwtPayload {\n\tiss?: string;\n\tsub?: string;\n\taud?: string[] | string;\n\texp?: number;\n\tnbf?: number;\n\tiat?: number;\n\tjti?: string;\n}\n\nexport class InvalidTokenError extends Error {}\n\nInvalidTokenError.prototype.name = 'InvalidTokenError';\n\nfunction b64DecodeUnicode(str: string) {\n\treturn decodeURIComponent(\n\t\tatob(str).replace(/(.)/g, (_m, p) => {\n\t\t\tlet code = (p as string).charCodeAt(0).toString(16).toUpperCase();\n\t\t\tif (code.length < 2) {\n\t\t\t\tcode = '0' + code;\n\t\t\t}\n\t\t\treturn '%' + code;\n\t\t}),\n\t);\n}\n\nfunction base64UrlDecode(str: string) {\n\tlet output = str.replace(/-/g, '+').replace(/_/g, '/');\n\tswitch (output.length % 4) {\n\t\tcase 0:\n\t\t\tbreak;\n\t\tcase 2:\n\t\t\toutput += '==';\n\t\t\tbreak;\n\t\tcase 3:\n\t\t\toutput += '=';\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow new Error('base64 string is not of the correct length');\n\t}\n\n\ttry {\n\t\treturn b64DecodeUnicode(output);\n\t} catch {\n\t\treturn atob(output);\n\t}\n}\n\nexport function jwtDecode<T = JwtHeader>(\n\ttoken: string,\n\toptions: JwtDecodeOptions & { header: true },\n): T;\nexport function jwtDecode<T = JwtPayload>(token: string, options?: JwtDecodeOptions): T;\nexport function jwtDecode<T = JwtHeader | JwtPayload>(\n\ttoken: string,\n\toptions?: JwtDecodeOptions,\n): T {\n\tif (typeof token !== 'string') {\n\t\tthrow new InvalidTokenError('Invalid token specified: must be a string');\n\t}\n\n\toptions ||= {};\n\n\tconst pos = options.header === true ? 0 : 1;\n\tconst part = token.split('.')[pos];\n\n\tif (typeof part !== 'string') {\n\t\tthrow new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);\n\t}\n\n\tlet decoded: string;\n\ttry {\n\t\tdecoded = base64UrlDecode(part);\n\t} catch (e) {\n\t\tthrow new InvalidTokenError(\n\t\t\t`Invalid token specified: invalid base64 for part #${pos + 1} (${(e as Error).message})`,\n\t\t);\n\t}\n\n\ttry {\n\t\treturn JSON.parse(decoded) as T;\n\t} catch (e) {\n\t\tthrow new InvalidTokenError(\n\t\t\t`Invalid token specified: invalid json for part #${pos + 1} (${(e as Error).message})`,\n\t\t);\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkDO,MAAM,0BAA0B,MAAM;AAAC;AAE9C,kBAAkB,UAAU,OAAO;AAEnC,SAAS,iBAAiB,KAAa;AACtC,SAAO;AAAA,IACN,KAAK,GAAG,EAAE,QAAQ,QAAQ,CAAC,IAAI,MAAM;AACpC,UAAI,OAAQ,EAAa,WAAW,CAAC,EAAE,SAAS,EAAE,EAAE,YAAY;AAChE,UAAI,KAAK,SAAS,GAAG;AACpB,eAAO,MAAM;AAAA,MACd;AACA,aAAO,MAAM;AAAA,IACd,CAAC;AAAA,EACF;AACD;AAEA,SAAS,gBAAgB,KAAa;AACrC,MAAI,SAAS,IAAI,QAAQ,MAAM,GAAG,EAAE,QAAQ,MAAM,GAAG;AACrD,UAAQ,OAAO,SAAS,GAAG;AAAA,IAC1B,KAAK;AACJ;AAAA,IACD,KAAK;AACJ,gBAAU;AACV;AAAA,IACD,KAAK;AACJ,gBAAU;AACV;AAAA,IACD;AACC,YAAM,IAAI,MAAM,4CAA4C;AAAA,EAC9D;AAEA,MAAI;AACH,WAAO,iBAAiB,MAAM;AAAA,EAC/B,QAAQ;AACP,WAAO,KAAK,MAAM;AAAA,EACnB;AACD;AAOO,SAAS,UACf,OACA,SACI;AACJ,MAAI,OAAO,UAAU,UAAU;AAC9B,UAAM,IAAI,kBAAkB,2CAA2C;AAAA,EACxE;AAEA,wBAAY,CAAC;AAEb,QAAM,MAAM,QAAQ,WAAW,OAAO,IAAI;AAC1C,QAAM,OAAO,MAAM,MAAM,GAAG,EAAE,GAAG;AAEjC,MAAI,OAAO,SAAS,UAAU;AAC7B,UAAM,IAAI,kBAAkB,0CAA0C,MAAM,CAAC,EAAE;AAAA,EAChF;AAEA,MAAI;AACJ,MAAI;AACH,cAAU,gBAAgB,IAAI;AAAA,EAC/B,SAAS,GAAG;AACX,UAAM,IAAI;AAAA,MACT,qDAAqD,MAAM,CAAC,KAAM,EAAY,OAAO;AAAA,IACtF;AAAA,EACD;AAEA,MAAI;AACH,WAAO,KAAK,MAAM,OAAO;AAAA,EAC1B,SAAS,GAAG;AACX,UAAM,IAAI;AAAA,MACT,mDAAmD,MAAM,CAAC,KAAM,EAAY,OAAO;AAAA,IACpF;AAAA,EACD;AACD;",
+  "names": []
+}

package/dist/cjs/zklogin/jwt-utils.d.ts

@@ -0,0 +1,12 @@
+import type { JwtPayload } from './jwt-decode.js';
+export type Claim = {
+    value: string;
+    indexMod4: number;
+};
+export declare function extractClaimValue<R>(claim: Claim, claimName: string): R;
+export declare function decodeJwt(jwt: string): Omit<JwtPayload, 'iss' | 'aud' | 'sub'> & {
+    iss: string;
+    aud: string;
+    sub: string;
+    rawIss: string;
+};

package/dist/cjs/zklogin/jwt-utils.js

@@ -0,0 +1,121 @@
+"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 jwt_utils_exports = {};
+__export(jwt_utils_exports, {
+  decodeJwt: () => decodeJwt,
+  extractClaimValue: () => extractClaimValue
+});
+module.exports = __toCommonJS(jwt_utils_exports);
+var import_jwt_decode = require("./jwt-decode.js");
+var import_utils = require("./utils.js");
+function base64UrlCharTo6Bits(base64UrlChar) {
+  if (base64UrlChar.length !== 1) {
+    throw new Error("Invalid base64Url character: " + base64UrlChar);
+  }
+  const base64UrlCharacterSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  const index = base64UrlCharacterSet.indexOf(base64UrlChar);
+  if (index === -1) {
+    throw new Error("Invalid base64Url character: " + base64UrlChar);
+  }
+  const binaryString = index.toString(2).padStart(6, "0");
+  const bits = Array.from(binaryString).map(Number);
+  return bits;
+}
+function base64UrlStringToBitVector(base64UrlString) {
+  let bitVector = [];
+  for (let i = 0; i < base64UrlString.length; i++) {
+    const base64UrlChar = base64UrlString.charAt(i);
+    const bits = base64UrlCharTo6Bits(base64UrlChar);
+    bitVector = bitVector.concat(bits);
+  }
+  return bitVector;
+}
+function decodeBase64URL(s, i) {
+  if (s.length < 2) {
+    throw new Error(`Input (s = ${s}) is not tightly packed because s.length < 2`);
+  }
+  let bits = base64UrlStringToBitVector(s);
+  const firstCharOffset = i % 4;
+  if (firstCharOffset === 0) {
+  } else if (firstCharOffset === 1) {
+    bits = bits.slice(2);
+  } else if (firstCharOffset === 2) {
+    bits = bits.slice(4);
+  } else {
+    throw new Error(`Input (s = ${s}) is not tightly packed because i%4 = 3 (i = ${i}))`);
+  }
+  const lastCharOffset = (i + s.length - 1) % 4;
+  if (lastCharOffset === 3) {
+  } else if (lastCharOffset === 2) {
+    bits = bits.slice(0, bits.length - 2);
+  } else if (lastCharOffset === 1) {
+    bits = bits.slice(0, bits.length - 4);
+  } else {
+    throw new Error(
+      `Input (s = ${s}) is not tightly packed because (i + s.length - 1)%4 = 0 (i = ${i}))`
+    );
+  }
+  if (bits.length % 8 !== 0) {
+    throw new Error(`We should never reach here...`);
+  }
+  const bytes = new Uint8Array(Math.floor(bits.length / 8));
+  let currentByteIndex = 0;
+  for (let i2 = 0; i2 < bits.length; i2 += 8) {
+    const bitChunk = bits.slice(i2, i2 + 8);
+    const byte = parseInt(bitChunk.join(""), 2);
+    bytes[currentByteIndex++] = byte;
+  }
+  return new TextDecoder().decode(bytes);
+}
+function verifyExtendedClaim(claim) {
+  if (!(claim.slice(-1) === "}" || claim.slice(-1) === ",")) {
+    throw new Error("Invalid claim");
+  }
+  const json = JSON.parse("{" + claim.slice(0, -1) + "}");
+  if (Object.keys(json).length !== 1) {
+    throw new Error("Invalid claim");
+  }
+  const key = Object.keys(json)[0];
+  return [key, json[key]];
+}
+function extractClaimValue(claim, claimName) {
+  const extendedClaim = decodeBase64URL(claim.value, claim.indexMod4);
+  const [name, value] = verifyExtendedClaim(extendedClaim);
+  if (name !== claimName) {
+    throw new Error(`Invalid field name: found ${name} expected ${claimName}`);
+  }
+  return value;
+}
+function decodeJwt(jwt) {
+  const { iss, aud, sub, ...decodedJWT } = (0, import_jwt_decode.jwtDecode)(jwt);
+  if (!sub || !iss || !aud) {
+    throw new Error("Missing jwt data");
+  }
+  if (Array.isArray(aud)) {
+    throw new Error("Not supported aud. Aud is an array, string was expected.");
+  }
+  return {
+    ...decodedJWT,
+    iss: (0, import_utils.normalizeZkLoginIssuer)(iss),
+    rawIss: iss,
+    aud,
+    sub
+  };
+}
+//# sourceMappingURL=jwt-utils.js.map

package/dist/cjs/zklogin/jwt-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/jwt-utils.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { JwtPayload } from './jwt-decode.js';\nimport { jwtDecode } from './jwt-decode.js';\nimport { normalizeZkLoginIssuer } from './utils.js';\n\nfunction base64UrlCharTo6Bits(base64UrlChar: string): number[] {\n\tif (base64UrlChar.length !== 1) {\n\t\tthrow new Error('Invalid base64Url character: ' + base64UrlChar);\n\t}\n\n\t// Define the base64URL character set\n\tconst base64UrlCharacterSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';\n\n\t// Find the index of the input character in the base64URL character set\n\tconst index = base64UrlCharacterSet.indexOf(base64UrlChar);\n\n\tif (index === -1) {\n\t\tthrow new Error('Invalid base64Url character: ' + base64UrlChar);\n\t}\n\n\t// Convert the index to a 6-bit binary string\n\tconst binaryString = index.toString(2).padStart(6, '0');\n\n\t// Convert the binary string to an array of bits\n\tconst bits = Array.from(binaryString).map(Number);\n\n\treturn bits;\n}\n\nfunction base64UrlStringToBitVector(base64UrlString: string) {\n\tlet bitVector: number[] = [];\n\tfor (let i = 0; i < base64UrlString.length; i++) {\n\t\tconst base64UrlChar = base64UrlString.charAt(i);\n\t\tconst bits = base64UrlCharTo6Bits(base64UrlChar);\n\t\tbitVector = bitVector.concat(bits);\n\t}\n\treturn bitVector;\n}\n\nfunction decodeBase64URL(s: string, i: number): string {\n\tif (s.length < 2) {\n\t\tthrow new Error(`Input (s = ${s}) is not tightly packed because s.length < 2`);\n\t}\n\tlet bits = base64UrlStringToBitVector(s);\n\n\tconst firstCharOffset = i % 4;\n\tif (firstCharOffset === 0) {\n\t\t// skip\n\t} else if (firstCharOffset === 1) {\n\t\tbits = bits.slice(2);\n\t} else if (firstCharOffset === 2) {\n\t\tbits = bits.slice(4);\n\t} else {\n\t\t// (offset == 3)\n\t\tthrow new Error(`Input (s = ${s}) is not tightly packed because i%4 = 3 (i = ${i}))`);\n\t}\n\n\tconst lastCharOffset = (i + s.length - 1) % 4;\n\tif (lastCharOffset === 3) {\n\t\t// skip\n\t} else if (lastCharOffset === 2) {\n\t\tbits = bits.slice(0, bits.length - 2);\n\t} else if (lastCharOffset === 1) {\n\t\tbits = bits.slice(0, bits.length - 4);\n\t} else {\n\t\t// (offset == 0)\n\t\tthrow new Error(\n\t\t\t`Input (s = ${s}) is not tightly packed because (i + s.length - 1)%4 = 0 (i = ${i}))`,\n\t\t);\n\t}\n\n\tif (bits.length % 8 !== 0) {\n\t\tthrow new Error(`We should never reach here...`);\n\t}\n\n\tconst bytes = new Uint8Array(Math.floor(bits.length / 8));\n\tlet currentByteIndex = 0;\n\tfor (let i = 0; i < bits.length; i += 8) {\n\t\tconst bitChunk = bits.slice(i, i + 8);\n\n\t\t// Convert the 8-bit chunk to a byte and add it to the bytes array\n\t\tconst byte = parseInt(bitChunk.join(''), 2);\n\t\tbytes[currentByteIndex++] = byte;\n\t}\n\treturn new TextDecoder().decode(bytes);\n}\n\nfunction verifyExtendedClaim(claim: string) {\n\t// Last character of each extracted_claim must be '}' or ','\n\tif (!(claim.slice(-1) === '}' || claim.slice(-1) === ',')) {\n\t\tthrow new Error('Invalid claim');\n\t}\n\n\t// A hack to parse the JSON key-value pair.. but it should work\n\tconst json = JSON.parse('{' + claim.slice(0, -1) + '}');\n\tif (Object.keys(json).length !== 1) {\n\t\tthrow new Error('Invalid claim');\n\t}\n\tconst key = Object.keys(json)[0];\n\treturn [key, json[key]];\n}\n\nexport type Claim = {\n\tvalue: string;\n\tindexMod4: number;\n};\n\nexport function extractClaimValue<R>(claim: Claim, claimName: string): R {\n\tconst extendedClaim = decodeBase64URL(claim.value, claim.indexMod4);\n\tconst [name, value] = verifyExtendedClaim(extendedClaim);\n\tif (name !== claimName) {\n\t\tthrow new Error(`Invalid field name: found ${name} expected ${claimName}`);\n\t}\n\treturn value;\n}\n\nexport function decodeJwt(jwt: string): Omit<JwtPayload, 'iss' | 'aud' | 'sub'> & {\n\tiss: string;\n\taud: string;\n\tsub: string;\n\trawIss: string;\n} {\n\tconst { iss, aud, sub, ...decodedJWT } = jwtDecode(jwt);\n\n\tif (!sub || !iss || !aud) {\n\t\tthrow new Error('Missing jwt data');\n\t}\n\n\tif (Array.isArray(aud)) {\n\t\tthrow new Error('Not supported aud. Aud is an array, string was expected.');\n\t}\n\n\treturn {\n\t\t...decodedJWT,\n\t\tiss: normalizeZkLoginIssuer(iss),\n\t\trawIss: iss,\n\t\taud,\n\t\tsub,\n\t};\n}\n"],
+  "mappings": "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",
+  "names": ["i"]
+}

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

@@ -0,0 +1,4 @@
+import type { PublicKey } from '../cryptography/publickey.js';
+export declare const NONCE_LENGTH = 27;
+export declare function generateRandomness(): string;
+export declare function generateNonce(publicKey: PublicKey, maxEpoch: number, randomness: bigint | string): string;

package/dist/cjs/zklogin/nonce.js

@@ -0,0 +1,54 @@
+"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 nonce_exports = {};
+__export(nonce_exports, {
+  NONCE_LENGTH: () => NONCE_LENGTH,
+  generateNonce: () => generateNonce,
+  generateRandomness: () => generateRandomness
+});
+module.exports = __toCommonJS(nonce_exports);
+var import_bcs = require("@haneullabs/bcs");
+var import_utils = require("@noble/hashes/utils");
+var import_base = require("@scure/base");
+var import_poseidon = require("./poseidon.js");
+var import_utils2 = require("./utils.js");
+const NONCE_LENGTH = 27;
+function toBigIntBE(bytes) {
+  const hex = (0, import_bcs.toHex)(bytes);
+  if (hex.length === 0) {
+    return BigInt(0);
+  }
+  return BigInt(`0x${hex}`);
+}
+function generateRandomness() {
+  return String(toBigIntBE((0, import_utils.randomBytes)(16)));
+}
+function generateNonce(publicKey, maxEpoch, randomness) {
+  const publicKeyBytes = toBigIntBE(publicKey.toHaneulBytes());
+  const eph_public_key_0 = publicKeyBytes / 2n ** 128n;
+  const eph_public_key_1 = publicKeyBytes % 2n ** 128n;
+  const bigNum = (0, import_poseidon.poseidonHash)([eph_public_key_0, eph_public_key_1, maxEpoch, BigInt(randomness)]);
+  const Z = (0, import_utils2.toPaddedBigEndianBytes)(bigNum, 20);
+  const nonce = import_base.base64urlnopad.encode(Z);
+  if (nonce.length !== NONCE_LENGTH) {
+    throw new Error(`Length of nonce ${nonce} (${nonce.length}) is not equal to ${NONCE_LENGTH}`);
+  }
+  return nonce;
+}
+//# sourceMappingURL=nonce.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/nonce.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { toHex } from '@haneullabs/bcs';\nimport { randomBytes } from '@noble/hashes/utils';\nimport { base64urlnopad } from '@scure/base';\n\nimport type { PublicKey } from '../cryptography/publickey.js';\nimport { poseidonHash } from './poseidon.js';\nimport { toPaddedBigEndianBytes } from './utils.js';\n\nexport const NONCE_LENGTH = 27;\n\nfunction toBigIntBE(bytes: Uint8Array) {\n\tconst hex = toHex(bytes);\n\tif (hex.length === 0) {\n\t\treturn BigInt(0);\n\t}\n\treturn BigInt(`0x${hex}`);\n}\n\nexport function generateRandomness() {\n\t// Once Node 20 enters LTS, we can just use crypto.getRandomValues(new Uint8Array(16)), but until then we use `randomBytes` to improve compatibility:\n\treturn String(toBigIntBE(randomBytes(16)));\n}\n\nexport function generateNonce(publicKey: PublicKey, maxEpoch: number, randomness: bigint | string) {\n\tconst publicKeyBytes = toBigIntBE(publicKey.toHaneulBytes());\n\tconst eph_public_key_0 = publicKeyBytes / 2n ** 128n;\n\tconst eph_public_key_1 = publicKeyBytes % 2n ** 128n;\n\tconst bigNum = poseidonHash([eph_public_key_0, eph_public_key_1, maxEpoch, BigInt(randomness)]);\n\tconst Z = toPaddedBigEndianBytes(bigNum, 20);\n\tconst nonce = base64urlnopad.encode(Z);\n\n\tif (nonce.length !== NONCE_LENGTH) {\n\t\tthrow new Error(`Length of nonce ${nonce} (${nonce.length}) is not equal to ${NONCE_LENGTH}`);\n\t}\n\treturn nonce;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAAsB;AACtB,mBAA4B;AAC5B,kBAA+B;AAG/B,sBAA6B;AAC7B,IAAAA,gBAAuC;AAEhC,MAAM,eAAe;AAE5B,SAAS,WAAW,OAAmB;AACtC,QAAM,UAAM,kBAAM,KAAK;AACvB,MAAI,IAAI,WAAW,GAAG;AACrB,WAAO,OAAO,CAAC;AAAA,EAChB;AACA,SAAO,OAAO,KAAK,GAAG,EAAE;AACzB;AAEO,SAAS,qBAAqB;AAEpC,SAAO,OAAO,eAAW,0BAAY,EAAE,CAAC,CAAC;AAC1C;AAEO,SAAS,cAAc,WAAsB,UAAkB,YAA6B;AAClG,QAAM,iBAAiB,WAAW,UAAU,cAAc,CAAC;AAC3D,QAAM,mBAAmB,iBAAiB,MAAM;AAChD,QAAM,mBAAmB,iBAAiB,MAAM;AAChD,QAAM,aAAS,8BAAa,CAAC,kBAAkB,kBAAkB,UAAU,OAAO,UAAU,CAAC,CAAC;AAC9F,QAAM,QAAI,sCAAuB,QAAQ,EAAE;AAC3C,QAAM,QAAQ,2BAAe,OAAO,CAAC;AAErC,MAAI,MAAM,WAAW,cAAc;AAClC,UAAM,IAAI,MAAM,mBAAmB,KAAK,KAAK,MAAM,MAAM,qBAAqB,YAAY,EAAE;AAAA,EAC7F;AACA,SAAO;AACR;",
+  "names": ["import_utils"]
+}

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

@@ -0,0 +1,2 @@
+export declare const BN254_FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+export declare function poseidonHash(inputs: (number | bigint | string)[]): bigint;

package/dist/cjs/zklogin/poseidon.js

@@ -0,0 +1,63 @@
+"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 poseidon_exports = {};
+__export(poseidon_exports, {
+  BN254_FIELD_SIZE: () => BN254_FIELD_SIZE,
+  poseidonHash: () => poseidonHash
+});
+module.exports = __toCommonJS(poseidon_exports);
+var import_poseidon_lite = require("poseidon-lite");
+const poseidonNumToHashFN = [
+  import_poseidon_lite.poseidon1,
+  import_poseidon_lite.poseidon2,
+  import_poseidon_lite.poseidon3,
+  import_poseidon_lite.poseidon4,
+  import_poseidon_lite.poseidon5,
+  import_poseidon_lite.poseidon6,
+  import_poseidon_lite.poseidon7,
+  import_poseidon_lite.poseidon8,
+  import_poseidon_lite.poseidon9,
+  import_poseidon_lite.poseidon10,
+  import_poseidon_lite.poseidon11,
+  import_poseidon_lite.poseidon12,
+  import_poseidon_lite.poseidon13,
+  import_poseidon_lite.poseidon14,
+  import_poseidon_lite.poseidon15,
+  import_poseidon_lite.poseidon16
+];
+const BN254_FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+function poseidonHash(inputs) {
+  inputs.forEach((x) => {
+    const b = BigInt(x);
+    if (b < 0 || b >= BN254_FIELD_SIZE) {
+      throw new Error(`Element ${b} not in the BN254 field`);
+    }
+  });
+  const hashFN = poseidonNumToHashFN[inputs.length - 1];
+  if (hashFN) {
+    return hashFN(inputs);
+  } else if (inputs.length <= 32) {
+    const hash1 = poseidonHash(inputs.slice(0, 16));
+    const hash2 = poseidonHash(inputs.slice(16));
+    return poseidonHash([hash1, hash2]);
+  } else {
+    throw new Error(`Yet to implement: Unable to hash a vector of length ${inputs.length}`);
+  }
+}
+//# sourceMappingURL=poseidon.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/poseidon.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n\tposeidon1,\n\tposeidon2,\n\tposeidon3,\n\tposeidon4,\n\tposeidon5,\n\tposeidon6,\n\tposeidon7,\n\tposeidon8,\n\tposeidon9,\n\tposeidon10,\n\tposeidon11,\n\tposeidon12,\n\tposeidon13,\n\tposeidon14,\n\tposeidon15,\n\tposeidon16,\n} from 'poseidon-lite';\n\nconst poseidonNumToHashFN = [\n\tposeidon1,\n\tposeidon2,\n\tposeidon3,\n\tposeidon4,\n\tposeidon5,\n\tposeidon6,\n\tposeidon7,\n\tposeidon8,\n\tposeidon9,\n\tposeidon10,\n\tposeidon11,\n\tposeidon12,\n\tposeidon13,\n\tposeidon14,\n\tposeidon15,\n\tposeidon16,\n];\n\nexport const BN254_FIELD_SIZE =\n\t21888242871839275222246405745257275088548364400416034343698204186575808495617n;\n\nexport function poseidonHash(inputs: (number | bigint | string)[]): bigint {\n\tinputs.forEach((x) => {\n\t\tconst b = BigInt(x);\n\t\tif (b < 0 || b >= BN254_FIELD_SIZE) {\n\t\t\tthrow new Error(`Element ${b} not in the BN254 field`);\n\t\t}\n\t});\n\n\tconst hashFN = poseidonNumToHashFN[inputs.length - 1];\n\n\tif (hashFN) {\n\t\treturn hashFN(inputs);\n\t} else if (inputs.length <= 32) {\n\t\tconst hash1 = poseidonHash(inputs.slice(0, 16));\n\t\tconst hash2 = poseidonHash(inputs.slice(16));\n\t\treturn poseidonHash([hash1, hash2]);\n\t} else {\n\t\tthrow new Error(`Yet to implement: Unable to hash a vector of length ${inputs.length}`);\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,2BAiBO;AAEP,MAAM,sBAAsB;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD;AAEO,MAAM,mBACZ;AAEM,SAAS,aAAa,QAA8C;AAC1E,SAAO,QAAQ,CAAC,MAAM;AACrB,UAAM,IAAI,OAAO,CAAC;AAClB,QAAI,IAAI,KAAK,KAAK,kBAAkB;AACnC,YAAM,IAAI,MAAM,WAAW,CAAC,yBAAyB;AAAA,IACtD;AAAA,EACD,CAAC;AAED,QAAM,SAAS,oBAAoB,OAAO,SAAS,CAAC;AAEpD,MAAI,QAAQ;AACX,WAAO,OAAO,MAAM;AAAA,EACrB,WAAW,OAAO,UAAU,IAAI;AAC/B,UAAM,QAAQ,aAAa,OAAO,MAAM,GAAG,EAAE,CAAC;AAC9C,UAAM,QAAQ,aAAa,OAAO,MAAM,EAAE,CAAC;AAC3C,WAAO,aAAa,CAAC,OAAO,KAAK,CAAC;AAAA,EACnC,OAAO;AACN,UAAM,IAAI,MAAM,uDAAuD,OAAO,MAAM,EAAE;AAAA,EACvF;AACD;",
+  "names": []
+}

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

@@ -0,0 +1,87 @@
+import { PublicKey } from '../cryptography/publickey.js';
+import type { PublicKeyInitData } from '../cryptography/publickey.js';
+import type { ZkLoginSignatureInputs } from './bcs.js';
+import type { ClientWithExtensions, Experimental_HaneulClientTypes } from '../experimental/types.js';
+export interface ZkLoginCompatibleClient extends ClientWithExtensions<{
+    core: {
+        verifyZkLoginSignature: Experimental_HaneulClientTypes.TransportMethods['verifyZkLoginSignature'];
+    };
+}> {
+}
+/**
+ * A zkLogin public identifier
+ */
+export declare class ZkLoginPublicIdentifier extends PublicKey {
+    #private;
+    /**
+     * Create a new ZkLoginPublicIdentifier object
+     * @param value zkLogin public identifier as buffer or base-64 encoded string
+     */
+    constructor(value: PublicKeyInitData, { client }?: {
+        client?: ZkLoginCompatibleClient;
+    });
+    static fromBytes(bytes: Uint8Array, { client, address, legacyAddress, }?: {
+        client?: ZkLoginCompatibleClient;
+        address?: string;
+        legacyAddress?: boolean;
+    }): ZkLoginPublicIdentifier;
+    static fromProof(address: string, proof: ZkLoginSignatureInputs): ZkLoginPublicIdentifier;
+    /**
+     * Checks if two zkLogin public identifiers are equal
+     */
+    equals(publicKey: ZkLoginPublicIdentifier): boolean;
+    toHaneulAddress(): string;
+    /**
+     * Return the byte array representation of the zkLogin public identifier
+     */
+    toRawBytes(): Uint8Array<ArrayBuffer>;
+    /**
+     * Return the Haneul address associated with this ZkLogin public identifier
+     */
+    flag(): number;
+    /**
+     * Verifies that the signature is valid for for the provided message
+     */
+    verify(_message: Uint8Array, _signature: Uint8Array | string): Promise<boolean>;
+    /**
+     * Verifies that the signature is valid for for the provided PersonalMessage
+     */
+    verifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+    /**
+     * Verifies that the signature is valid for for the provided Transaction
+     */
+    verifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean>;
+    /**
+     * Verifies that the public key is associated with the provided address
+     */
+    verifyAddress(address: string): boolean;
+}
+export declare function toZkLoginPublicIdentifier(addressSeed: bigint, iss: string, options?: {
+    client?: ZkLoginCompatibleClient;
+    legacyAddress?: boolean;
+}): ZkLoginPublicIdentifier;
+export declare function parseSerializedZkLoginSignature(signature: Uint8Array | string): {
+    serializedSignature: string;
+    signatureScheme: "ZkLogin";
+    zkLogin: {
+        inputs: {
+            proofPoints: {
+                a: string[];
+                b: string[][];
+                c: string[];
+            };
+            issBase64Details: {
+                value: string;
+                indexMod4: number;
+            };
+            headerBase64: string;
+            addressSeed: string;
+        };
+        maxEpoch: string;
+        userSignature: Uint8Array<ArrayBufferLike>;
+        iss: string;
+        addressSeed: bigint;
+    };
+    signature: Uint8Array<ArrayBufferLike>;
+    publicKey: Uint8Array<ArrayBuffer>;
+};