wowok 1.8.2 → 2.1.9

package/dist/esm/zklogin/address.js

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,40 @@
+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

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

package/dist/esm/zklogin/publickey.js

@@ -0,0 +1,265 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _data, _client, _legacyAddress, _ZkLoginPublicIdentifier_instances, toLegacyAddress_fn;
+import { fromBase64, toBase64, toHex } from "@mysten/bcs";
+import { blake2b } from "@noble/hashes/blake2b";
+import { bytesToHex } from "@noble/hashes/utils";
+import { PublicKey } from "../cryptography/publickey.js";
+import { SIGNATURE_SCHEME_TO_FLAG } from "../cryptography/signature-scheme.js";
+import { SuiGraphQLClient } from "../graphql/client.js";
+import { normalizeWowAddress, WOW_ADDRESS_LENGTH } from "../utils/sui-types.js";
+import { extractClaimValue } from "./jwt-utils.js";
+import { parseZkLoginSignature } from "./signature.js";
+import {
+  normalizeZkLoginIssuer,
+  toBigEndianBytes,
+  toPaddedBigEndianBytes
+} from "./utils.js";
+const _ZkLoginPublicIdentifier = class _ZkLoginPublicIdentifier extends PublicKey {
+  /**
+   * Create a new ZkLoginPublicIdentifier object
+   * @param value zkLogin public identifier as buffer or base-64 encoded string
+   */
+  constructor(value, { client } = {}) {
+    super();
+    __privateAdd(this, _ZkLoginPublicIdentifier_instances);
+    __privateAdd(this, _data);
+    __privateAdd(this, _client);
+    __privateAdd(this, _legacyAddress);
+    __privateSet(this, _client, client);
+    if (typeof value === "string") {
+      __privateSet(this, _data, fromBase64(value));
+    } else if (value instanceof Uint8Array) {
+      __privateSet(this, _data, value);
+    } else {
+      __privateSet(this, _data, Uint8Array.from(value));
+    }
+    __privateSet(this, _legacyAddress, __privateGet(this, _data).length !== __privateGet(this, _data)[0] + 1 + 32);
+    if (__privateGet(this, _legacyAddress)) {
+      __privateSet(this, _data, normalizeZkLoginPublicKeyBytes(__privateGet(this, _data)));
+    }
+  }
+  static fromBytes(bytes, {
+    client,
+    address,
+    legacyAddress
+  } = {}) {
+    let publicKey;
+    if (legacyAddress === true) {
+      publicKey = new _ZkLoginPublicIdentifier(
+        normalizeZkLoginPublicKeyBytes(bytes, true),
+        {
+          client
+        }
+      );
+    } else if (legacyAddress === false) {
+      publicKey = new _ZkLoginPublicIdentifier(
+        normalizeZkLoginPublicKeyBytes(bytes, false),
+        {
+          client
+        }
+      );
+    } else if (address) {
+      publicKey = new _ZkLoginPublicIdentifier(
+        normalizeZkLoginPublicKeyBytes(bytes, false),
+        {
+          client
+        }
+      );
+      if (publicKey.toWAddress() !== address) {
+        publicKey = new _ZkLoginPublicIdentifier(
+          normalizeZkLoginPublicKeyBytes(bytes, true),
+          {
+            client
+          }
+        );
+      }
+    } else {
+      publicKey = new _ZkLoginPublicIdentifier(bytes, {
+        client
+      });
+    }
+    if (address && publicKey.toWAddress() !== address) {
+      throw new Error("Public key does not match the provided address");
+    }
+    return publicKey;
+  }
+  static fromProof(address, proof) {
+    const { issBase64Details, addressSeed } = proof;
+    const iss = extractClaimValue(issBase64Details, "iss");
+    const legacyPublicKey = toZkLoginPublicIdentifier(
+      BigInt(addressSeed),
+      iss,
+      {
+        legacyAddress: true
+      }
+    );
+    if (legacyPublicKey.toWAddress() === address) {
+      return legacyPublicKey;
+    }
+    const publicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, {
+      legacyAddress: false
+    });
+    if (publicKey.toWAddress() !== address) {
+      throw new Error("Proof does not match address");
+    }
+    return publicKey;
+  }
+  /**
+   * Checks if two zkLogin public identifiers are equal
+   */
+  equals(publicKey) {
+    return super.equals(publicKey);
+  }
+  toWAddress() {
+    if (__privateGet(this, _legacyAddress)) {
+      return __privateMethod(this, _ZkLoginPublicIdentifier_instances, toLegacyAddress_fn).call(this);
+    }
+    return super.toWAddress();
+  }
+  /**
+   * Return the byte array representation of the zkLogin public identifier
+   */
+  toRawBytes() {
+    return __privateGet(this, _data);
+  }
+  /**
+   * Return the Sui address associated with this ZkLogin public identifier
+   */
+  flag() {
+    return SIGNATURE_SCHEME_TO_FLAG["ZkLogin"];
+  }
+  /**
+   * Verifies that the signature is valid for for the provided message
+   */
+  async verify(_message, _signature) {
+    throw Error("does not support");
+  }
+  /**
+   * Verifies that the signature is valid for for the provided PersonalMessage
+   */
+  verifyPersonalMessage(message, signature) {
+    const parsedSignature = parseSerializedZkLoginSignature(signature);
+    const address = new _ZkLoginPublicIdentifier(
+      parsedSignature.publicKey
+    ).toWAddress();
+    return graphqlVerifyZkLoginSignature({
+      address,
+      bytes: toBase64(message),
+      signature: parsedSignature.serializedSignature,
+      intentScope: "PersonalMessage",
+      client: __privateGet(this, _client)
+    });
+  }
+  /**
+   * Verifies that the signature is valid for for the provided Transaction
+   */
+  verifyTransaction(transaction, signature) {
+    const parsedSignature = parseSerializedZkLoginSignature(signature);
+    const address = new _ZkLoginPublicIdentifier(
+      parsedSignature.publicKey
+    ).toWAddress();
+    return graphqlVerifyZkLoginSignature({
+      address,
+      bytes: toBase64(transaction),
+      signature: parsedSignature.serializedSignature,
+      intentScope: "TransactionData",
+      client: __privateGet(this, _client)
+    });
+  }
+  /**
+   * Verifies that the public key is associated with the provided address
+   */
+  verifyAddress(address) {
+    return address === super.toWAddress() || address === __privateMethod(this, _ZkLoginPublicIdentifier_instances, toLegacyAddress_fn).call(this);
+  }
+};
+_data = new WeakMap();
+_client = new WeakMap();
+_legacyAddress = new WeakMap();
+_ZkLoginPublicIdentifier_instances = new WeakSet();
+toLegacyAddress_fn = function() {
+  const legacyBytes = normalizeZkLoginPublicKeyBytes(__privateGet(this, _data), true);
+  const addressBytes = new Uint8Array(legacyBytes.length + 1);
+  addressBytes[0] = this.flag();
+  addressBytes.set(legacyBytes, 1);
+  return normalizeWowAddress(
+    bytesToHex(blake2b(addressBytes, { dkLen: 32 })).slice(
+      0,
+      WOW_ADDRESS_LENGTH * 2
+    )
+  );
+};
+let ZkLoginPublicIdentifier = _ZkLoginPublicIdentifier;
+function toZkLoginPublicIdentifier(addressSeed, iss, options) {
+  const addressSeedBytesBigEndian = options?.legacyAddress ? toBigEndianBytes(addressSeed, 32) : toPaddedBigEndianBytes(addressSeed, 32);
+  const issBytes = new TextEncoder().encode(normalizeZkLoginIssuer(iss));
+  const tmp = new Uint8Array(
+    1 + issBytes.length + addressSeedBytesBigEndian.length
+  );
+  tmp.set([issBytes.length], 0);
+  tmp.set(issBytes, 1);
+  tmp.set(addressSeedBytesBigEndian, 1 + issBytes.length);
+  return new ZkLoginPublicIdentifier(tmp, options);
+}
+function normalizeZkLoginPublicKeyBytes(bytes, legacyAddress = false) {
+  const issByteLength = bytes[0] + 1;
+  const addressSeed = BigInt(`0x${toHex(bytes.slice(issByteLength))}`);
+  const seedBytes = legacyAddress ? toBigEndianBytes(addressSeed, 32) : toPaddedBigEndianBytes(addressSeed, 32);
+  const data = new Uint8Array(issByteLength + seedBytes.length);
+  data.set(bytes.slice(0, issByteLength), 0);
+  data.set(seedBytes, issByteLength);
+  return data;
+}
+async function graphqlVerifyZkLoginSignature({
+  address,
+  bytes,
+  signature,
+  intentScope,
+  client = new SuiGraphQLClient({
+    url: "https://graphql.mainnet.sui.io/graphql"
+  })
+}) {
+  const resp = await client.core.verifyZkLoginSignature({
+    bytes,
+    signature,
+    intentScope,
+    author: address
+  });
+  return resp.success === true && resp.errors.length === 0;
+}
+function parseSerializedZkLoginSignature(signature) {
+  const bytes = typeof signature === "string" ? fromBase64(signature) : signature;
+  if (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.ZkLogin) {
+    throw new Error("Invalid signature scheme");
+  }
+  const signatureBytes = bytes.slice(1);
+  const { inputs, maxEpoch, userSignature } = parseZkLoginSignature(signatureBytes);
+  const { issBase64Details, addressSeed } = inputs;
+  const iss = extractClaimValue(issBase64Details, "iss");
+  const publicIdentifer = toZkLoginPublicIdentifier(BigInt(addressSeed), iss);
+  return {
+    serializedSignature: toBase64(bytes),
+    signatureScheme: "ZkLogin",
+    zkLogin: {
+      inputs,
+      maxEpoch,
+      userSignature,
+      iss,
+      addressSeed: BigInt(addressSeed)
+    },
+    signature: bytes,
+    publicKey: publicIdentifer.toRawBytes()
+  };
+}
+export {
+  ZkLoginPublicIdentifier,
+  parseSerializedZkLoginSignature,
+  toZkLoginPublicIdentifier
+};