wowok 1.8.2 → 2.1.9

package/dist/cjs/zklogin/address.js

@@ -0,0 +1,93 @@
+"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.normalizeWowAddress)(
+    (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(tmp, { dkLen: 32 })).slice(
+      0,
+      import_utils2.WOW_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
+  );
+}

package/dist/cjs/zklogin/bcs.js

@@ -0,0 +1,41 @@
+"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("@mysten/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()
+});

package/dist/cjs/zklogin/index.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 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");

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

@@ -0,0 +1,88 @@
+"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})`
+    );
+  }
+}

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

@@ -0,0 +1,128 @@
+"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
+  };
+}

package/dist/cjs/zklogin/nonce.js

@@ -0,0 +1,60 @@
+"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("@mysten/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.toWBytes());
+  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;
+}

package/dist/cjs/zklogin/poseidon.js

@@ -0,0 +1,64 @@
+"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}`
+    );
+  }
+}