wowok 2.1.10 → 2.1.13

package/dist/esm/graphql/index.js

@@ -1,8 +0,0 @@
-import {
-  SuiGraphQLClient,
-  SuiGraphQLRequestError
-} from "./client.js";
-export {
-  SuiGraphQLClient,
-  SuiGraphQLRequestError
-};

package/dist/esm/graphql/schemas/2024.1/index.js

@@ -1,8 +0,0 @@
-import { initGraphQLTada } from "gql.tada";
-import { readFragment, maskFragments } from "gql.tada";
-const graphql = initGraphQLTada();
-export {
-  graphql,
-  maskFragments,
-  readFragment
-};

package/dist/esm/graphql/schemas/2024.4/index.js

@@ -1,8 +0,0 @@
-import { initGraphQLTada } from "gql.tada";
-import { readFragment, maskFragments } from "gql.tada";
-const graphql = initGraphQLTada();
-export {
-  graphql,
-  maskFragments,
-  readFragment
-};

package/dist/esm/graphql/schemas/latest/index.js

@@ -1,8 +0,0 @@
-import { initGraphQLTada } from "gql.tada";
-import { readFragment, maskFragments } from "gql.tada";
-const graphql = initGraphQLTada();
-export {
-  graphql,
-  maskFragments,
-  readFragment
-};

package/dist/esm/package.json

@@ -1,5 +0,0 @@
-{
-  "private": true,
-  "type": "module",
-  "sideEffects": false
-}

package/dist/esm/w/local/.eslintrc.js

@@ -1,23 +0,0 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var require_eslintrc = __commonJS({
-  "src/w/local/.eslintrc.cjs"(exports, module) {
-    module.exports = {
-      root: false,
-      rules: {
-        // Messenger 模块只在 Node.js 环境中使用，允许使用 Buffer
-        "no-restricted-globals": "off",
-        "@typescript-eslint/ban-types": [
-          "error",
-          {
-            types: {},
-            extendDefaults: true
-          }
-        ]
-      }
-    };
-  }
-});
-export default require_eslintrc();

package/dist/esm/w/messenger/.eslintrc.js

@@ -1,23 +0,0 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var require_eslintrc = __commonJS({
-  "src/w/messenger/.eslintrc.cjs"(exports, module) {
-    module.exports = {
-      root: false,
-      rules: {
-        // Messenger 模块只在 Node.js 环境中使用，允许使用 Buffer
-        "no-restricted-globals": "off",
-        "@typescript-eslint/ban-types": [
-          "error",
-          {
-            types: {},
-            extendDefaults: true
-          }
-        ]
-      }
-    };
-  }
-});
-export default require_eslintrc();

package/dist/esm/zklogin/address.js

@@ -1,78 +0,0 @@
-import { blake2b } from "@noble/hashes/blake2b";
-import { bytesToHex } from "@noble/hashes/utils";
-import { SIGNATURE_SCHEME_TO_FLAG } from "../cryptography/signature-scheme.js";
-import { normalizeWowAddress, WOW_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 normalizeWowAddress(
-    bytesToHex(blake2b(tmp, { dkLen: 32 })).slice(
-      0,
-      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 = 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
-};

package/dist/esm/zklogin/bcs.js

@@ -1,21 +0,0 @@
-import { bcs } from "@mysten/bcs";
-const zkLoginSignature = bcs.struct("ZkLoginSignature", {
-  inputs: bcs.struct("ZkLoginSignatureInputs", {
-    proofPoints: bcs.struct("ZkLoginSignatureInputsProofPoints", {
-      a: bcs.vector(bcs.string()),
-      b: bcs.vector(bcs.vector(bcs.string())),
-      c: bcs.vector(bcs.string())
-    }),
-    issBase64Details: bcs.struct("ZkLoginSignatureInputsClaim", {
-      value: bcs.string(),
-      indexMod4: bcs.u8()
-    }),
-    headerBase64: bcs.string(),
-    addressSeed: bcs.string()
-  }),
-  maxEpoch: bcs.u64(),
-  userSignature: bcs.byteVector()
-});
-export {
-  zkLoginSignature
-};

package/dist/esm/zklogin/index.js

@@ -1,38 +0,0 @@
-import { getZkLoginSignature, parseZkLoginSignature } from "./signature.js";
-import {
-  toBigEndianBytes,
-  toPaddedBigEndianBytes,
-  hashASCIIStrToField,
-  genAddressSeed,
-  getExtendedEphemeralPublicKey
-} from "./utils.js";
-import {
-  computeZkLoginAddressFromSeed,
-  computeZkLoginAddress,
-  jwtToAddress
-} from "./address.js";
-import {
-  toZkLoginPublicIdentifier,
-  ZkLoginPublicIdentifier
-} from "./publickey.js";
-import { poseidonHash } from "./poseidon.js";
-import { generateNonce, generateRandomness } from "./nonce.js";
-import { decodeJwt } from "./jwt-utils.js";
-export {
-  ZkLoginPublicIdentifier,
-  computeZkLoginAddress,
-  computeZkLoginAddressFromSeed,
-  decodeJwt,
-  genAddressSeed,
-  generateNonce,
-  generateRandomness,
-  getExtendedEphemeralPublicKey,
-  getZkLoginSignature,
-  hashASCIIStrToField,
-  jwtToAddress,
-  parseZkLoginSignature,
-  poseidonHash,
-  toBigEndianBytes,
-  toPaddedBigEndianBytes,
-  toZkLoginPublicIdentifier
-};

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

@@ -1,68 +0,0 @@
-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})`
-    );
-  }
-}
-export {
-  InvalidTokenError,
-  jwtDecode
-};

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

@@ -1,108 +0,0 @@
-import { jwtDecode } from "./jwt-decode.js";
-import { normalizeZkLoginIssuer } from "./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 } = 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: normalizeZkLoginIssuer(iss),
-    rawIss: iss,
-    aud,
-    sub
-  };
-}
-export {
-  decodeJwt,
-  extractClaimValue
-};

package/dist/esm/zklogin/nonce.js

@@ -1,40 +0,0 @@
-import { toHex } from "@mysten/bcs";
-import { randomBytes } from "@noble/hashes/utils";
-import { base64urlnopad } from "@scure/base";
-import { poseidonHash } from "./poseidon.js";
-import { toPaddedBigEndianBytes } from "./utils.js";
-const NONCE_LENGTH = 27;
-function toBigIntBE(bytes) {
-  const hex = toHex(bytes);
-  if (hex.length === 0) {
-    return BigInt(0);
-  }
-  return BigInt(`0x${hex}`);
-}
-function generateRandomness() {
-  return String(toBigIntBE(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 = poseidonHash([
-    eph_public_key_0,
-    eph_public_key_1,
-    maxEpoch,
-    BigInt(randomness)
-  ]);
-  const Z = toPaddedBigEndianBytes(bigNum, 20);
-  const nonce = 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;
-}
-export {
-  NONCE_LENGTH,
-  generateNonce,
-  generateRandomness
-};

package/dist/esm/zklogin/poseidon.js

@@ -1,61 +0,0 @@
-import {
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  poseidon16
-} from "poseidon-lite";
-const poseidonNumToHashFN = [
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  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}`
-    );
-  }
-}
-export {
-  BN254_FIELD_SIZE,
-  poseidonHash
-};