@haneullabs/haneul 0.1.0

package/dist/cjs/zklogin/publickey.js

@@ -0,0 +1,257 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __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 publickey_exports = {};
+__export(publickey_exports, {
+  ZkLoginPublicIdentifier: () => ZkLoginPublicIdentifier,
+  parseSerializedZkLoginSignature: () => parseSerializedZkLoginSignature,
+  toZkLoginPublicIdentifier: () => toZkLoginPublicIdentifier
+});
+module.exports = __toCommonJS(publickey_exports);
+var import_bcs = require("@haneullabs/bcs");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_utils = require("@noble/hashes/utils");
+var import_publickey = require("../cryptography/publickey.js");
+var import_signature_scheme = require("../cryptography/signature-scheme.js");
+var import_client = require("../graphql/client.js");
+var import_haneul_types = require("../utils/haneul-types.js");
+var import_jwt_utils = require("./jwt-utils.js");
+var import_signature = require("./signature.js");
+var import_utils2 = require("./utils.js");
+var _data, _client, _legacyAddress, _ZkLoginPublicIdentifier_instances, toLegacyAddress_fn;
+const _ZkLoginPublicIdentifier = class _ZkLoginPublicIdentifier extends import_publickey.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, (0, import_bcs.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.toHaneulAddress() !== address) {
+        publicKey = new _ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, true), {
+          client
+        });
+      }
+    } else {
+      publicKey = new _ZkLoginPublicIdentifier(bytes, {
+        client
+      });
+    }
+    if (address && publicKey.toHaneulAddress() !== address) {
+      throw new Error("Public key bytes do not match the provided address");
+    }
+    return publicKey;
+  }
+  static fromProof(address, proof) {
+    const { issBase64Details, addressSeed } = proof;
+    const iss = (0, import_jwt_utils.extractClaimValue)(issBase64Details, "iss");
+    const legacyPublicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, {
+      legacyAddress: true
+    });
+    if (legacyPublicKey.toHaneulAddress() === address) {
+      return legacyPublicKey;
+    }
+    const publicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, {
+      legacyAddress: false
+    });
+    if (publicKey.toHaneulAddress() !== 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);
+  }
+  toHaneulAddress() {
+    if (__privateGet(this, _legacyAddress)) {
+      return __privateMethod(this, _ZkLoginPublicIdentifier_instances, toLegacyAddress_fn).call(this);
+    }
+    return super.toHaneulAddress();
+  }
+  /**
+   * Return the byte array representation of the zkLogin public identifier
+   */
+  toRawBytes() {
+    return __privateGet(this, _data);
+  }
+  /**
+   * Return the Haneul address associated with this ZkLogin public identifier
+   */
+  flag() {
+    return import_signature_scheme.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).toHaneulAddress();
+    return graphqlVerifyZkLoginSignature({
+      address,
+      bytes: (0, import_bcs.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).toHaneulAddress();
+    return graphqlVerifyZkLoginSignature({
+      address,
+      bytes: (0, import_bcs.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.toHaneulAddress() || 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 (0, import_haneul_types.normalizeHaneulAddress)(
+    (0, import_utils.bytesToHex)((0, import_blake2b.blake2b)(addressBytes, { dkLen: 32 })).slice(0, import_haneul_types.HANEUL_ADDRESS_LENGTH * 2)
+  );
+};
+let ZkLoginPublicIdentifier = _ZkLoginPublicIdentifier;
+function toZkLoginPublicIdentifier(addressSeed, iss, options) {
+  const addressSeedBytesBigEndian = options?.legacyAddress ? (0, import_utils2.toBigEndianBytes)(addressSeed, 32) : (0, import_utils2.toPaddedBigEndianBytes)(addressSeed, 32);
+  const issBytes = new TextEncoder().encode((0, import_utils2.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${(0, import_bcs.toHex)(bytes.slice(issByteLength))}`);
+  const seedBytes = legacyAddress ? (0, import_utils2.toBigEndianBytes)(addressSeed, 32) : (0, import_utils2.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 import_client.HaneulGraphQLClient({
+    url: "https://graphql.mainnet.haneul.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" ? (0, import_bcs.fromBase64)(signature) : signature;
+  if (bytes[0] !== import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG.ZkLogin) {
+    throw new Error("Invalid signature scheme");
+  }
+  const signatureBytes = bytes.slice(1);
+  const { inputs, maxEpoch, userSignature } = (0, import_signature.parseZkLoginSignature)(signatureBytes);
+  const { issBase64Details, addressSeed } = inputs;
+  const iss = (0, import_jwt_utils.extractClaimValue)(issBase64Details, "iss");
+  const publicIdentifer = toZkLoginPublicIdentifier(BigInt(addressSeed), iss);
+  return {
+    serializedSignature: (0, import_bcs.toBase64)(bytes),
+    signatureScheme: "ZkLogin",
+    zkLogin: {
+      inputs,
+      maxEpoch,
+      userSignature,
+      iss,
+      addressSeed: BigInt(addressSeed)
+    },
+    signature: bytes,
+    publicKey: publicIdentifer.toRawBytes()
+  };
+}
+//# sourceMappingURL=publickey.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/publickey.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64, toHex } from '@haneullabs/bcs';\nimport { blake2b } from '@noble/hashes/blake2b';\nimport { bytesToHex } from '@noble/hashes/utils';\n\nimport { PublicKey } from '../cryptography/publickey.js';\nimport type { PublicKeyInitData } from '../cryptography/publickey.js';\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../cryptography/signature-scheme.js';\nimport { HaneulGraphQLClient } from '../graphql/client.js';\nimport { normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from '../utils/haneul-types.js';\nimport type { ZkLoginSignatureInputs } from './bcs.js';\nimport { extractClaimValue } from './jwt-utils.js';\nimport { parseZkLoginSignature } from './signature.js';\nimport { normalizeZkLoginIssuer, toBigEndianBytes, toPaddedBigEndianBytes } from './utils.js';\nimport type { ClientWithExtensions, Experimental_HaneulClientTypes } from '../experimental/types.js';\n\nexport interface ZkLoginCompatibleClient extends ClientWithExtensions<{\n\tcore: {\n\t\tverifyZkLoginSignature: Experimental_HaneulClientTypes.TransportMethods['verifyZkLoginSignature'];\n\t};\n}> {}\n\n/**\n * A zkLogin public identifier\n */\nexport class ZkLoginPublicIdentifier extends PublicKey {\n\t#data: Uint8Array<ArrayBuffer>;\n\t#client?: ZkLoginCompatibleClient;\n\t#legacyAddress: boolean;\n\n\t/**\n\t * Create a new ZkLoginPublicIdentifier object\n\t * @param value zkLogin public identifier as buffer or base-64 encoded string\n\t */\n\tconstructor(value: PublicKeyInitData, { client }: { client?: ZkLoginCompatibleClient } = {}) {\n\t\tsuper();\n\n\t\tthis.#client = client;\n\n\t\tif (typeof value === 'string') {\n\t\t\tthis.#data = fromBase64(value);\n\t\t} else if (value instanceof Uint8Array) {\n\t\t\tthis.#data = value as Uint8Array<ArrayBuffer>;\n\t\t} else {\n\t\t\tthis.#data = Uint8Array.from(value);\n\t\t}\n\t\tthis.#legacyAddress = this.#data.length !== this.#data[0] + 1 + 32;\n\n\t\tif (this.#legacyAddress) {\n\t\t\tthis.#data = normalizeZkLoginPublicKeyBytes(this.#data);\n\t\t}\n\t}\n\n\tstatic fromBytes(\n\t\tbytes: Uint8Array,\n\t\t{\n\t\t\tclient,\n\t\t\taddress,\n\t\t\tlegacyAddress,\n\t\t}: { client?: ZkLoginCompatibleClient; address?: string; legacyAddress?: boolean } = {},\n\t) {\n\t\tlet publicKey: ZkLoginPublicIdentifier;\n\n\t\tif (legacyAddress === true) {\n\t\t\tpublicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, true), {\n\t\t\t\tclient,\n\t\t\t});\n\t\t} else if (legacyAddress === false) {\n\t\t\tpublicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, false), {\n\t\t\t\tclient,\n\t\t\t});\n\t\t} else if (address) {\n\t\t\tpublicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, false), {\n\t\t\t\tclient,\n\t\t\t});\n\n\t\t\tif (publicKey.toHaneulAddress() !== address) {\n\t\t\t\tpublicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, true), {\n\t\t\t\t\tclient,\n\t\t\t\t});\n\t\t\t}\n\t\t} else {\n\t\t\tpublicKey = new ZkLoginPublicIdentifier(bytes, {\n\t\t\t\tclient,\n\t\t\t});\n\t\t}\n\n\t\tif (address && publicKey.toHaneulAddress() !== address) {\n\t\t\tthrow new Error('Public key bytes do not match the provided address');\n\t\t}\n\n\t\treturn publicKey;\n\t}\n\n\tstatic fromProof(address: string, proof: ZkLoginSignatureInputs) {\n\t\tconst { issBase64Details, addressSeed } = proof;\n\t\tconst iss = extractClaimValue<string>(issBase64Details, 'iss');\n\n\t\tconst legacyPublicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, {\n\t\t\tlegacyAddress: true,\n\t\t});\n\n\t\tif (legacyPublicKey.toHaneulAddress() === address) {\n\t\t\treturn legacyPublicKey;\n\t\t}\n\n\t\tconst publicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, {\n\t\t\tlegacyAddress: false,\n\t\t});\n\n\t\tif (publicKey.toHaneulAddress() !== address) {\n\t\t\tthrow new Error('Proof does not match address');\n\t\t}\n\n\t\treturn publicKey;\n\t}\n\n\t/**\n\t * Checks if two zkLogin public identifiers are equal\n\t */\n\toverride equals(publicKey: ZkLoginPublicIdentifier): boolean {\n\t\treturn super.equals(publicKey);\n\t}\n\n\toverride toHaneulAddress(): string {\n\t\tif (this.#legacyAddress) {\n\t\t\treturn this.#toLegacyAddress();\n\t\t}\n\n\t\treturn super.toHaneulAddress();\n\t}\n\n\t#toLegacyAddress() {\n\t\tconst legacyBytes = normalizeZkLoginPublicKeyBytes(this.#data, true);\n\t\tconst addressBytes = new Uint8Array(legacyBytes.length + 1);\n\t\taddressBytes[0] = this.flag();\n\t\taddressBytes.set(legacyBytes, 1);\n\t\treturn normalizeHaneulAddress(\n\t\t\tbytesToHex(blake2b(addressBytes, { dkLen: 32 })).slice(0, HANEUL_ADDRESS_LENGTH * 2),\n\t\t);\n\t}\n\n\t/**\n\t * Return the byte array representation of the zkLogin public identifier\n\t */\n\ttoRawBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn this.#data;\n\t}\n\n\t/**\n\t * Return the Haneul address associated with this ZkLogin public identifier\n\t */\n\tflag(): number {\n\t\treturn SIGNATURE_SCHEME_TO_FLAG['ZkLogin'];\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided message\n\t */\n\tasync verify(_message: Uint8Array, _signature: Uint8Array | string): Promise<boolean> {\n\t\tthrow Error('does not support');\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided PersonalMessage\n\t */\n\tverifyPersonalMessage(message: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\tconst parsedSignature = parseSerializedZkLoginSignature(signature);\n\t\tconst address = new ZkLoginPublicIdentifier(parsedSignature.publicKey).toHaneulAddress();\n\n\t\treturn graphqlVerifyZkLoginSignature({\n\t\t\taddress: address,\n\t\t\tbytes: toBase64(message),\n\t\t\tsignature: parsedSignature.serializedSignature,\n\t\t\tintentScope: 'PersonalMessage',\n\t\t\tclient: this.#client,\n\t\t});\n\t}\n\n\t/**\n\t * Verifies that the signature is valid for for the provided Transaction\n\t */\n\tverifyTransaction(transaction: Uint8Array, signature: Uint8Array | string): Promise<boolean> {\n\t\tconst parsedSignature = parseSerializedZkLoginSignature(signature);\n\t\tconst address = new ZkLoginPublicIdentifier(parsedSignature.publicKey).toHaneulAddress();\n\t\treturn graphqlVerifyZkLoginSignature({\n\t\t\taddress: address,\n\t\t\tbytes: toBase64(transaction),\n\t\t\tsignature: parsedSignature.serializedSignature,\n\t\t\tintentScope: 'TransactionData',\n\t\t\tclient: this.#client,\n\t\t});\n\t}\n\n\t/**\n\t * Verifies that the public key is associated with the provided address\n\t */\n\toverride verifyAddress(address: string): boolean {\n\t\treturn address === super.toHaneulAddress() || address === this.#toLegacyAddress();\n\t}\n}\n\n// Derive the public identifier for zklogin based on address seed and iss.\nexport function toZkLoginPublicIdentifier(\n\taddressSeed: bigint,\n\tiss: string,\n\toptions?: { client?: ZkLoginCompatibleClient; legacyAddress?: boolean },\n): ZkLoginPublicIdentifier {\n\t// Consists of iss_bytes_len || iss_bytes || padded_32_byte_address_seed.\n\tconst addressSeedBytesBigEndian = options?.legacyAddress\n\t\t? toBigEndianBytes(addressSeed, 32)\n\t\t: toPaddedBigEndianBytes(addressSeed, 32);\n\n\tconst issBytes = new TextEncoder().encode(normalizeZkLoginIssuer(iss));\n\tconst tmp = new Uint8Array(1 + issBytes.length + addressSeedBytesBigEndian.length);\n\ttmp.set([issBytes.length], 0);\n\ttmp.set(issBytes, 1);\n\ttmp.set(addressSeedBytesBigEndian, 1 + issBytes.length);\n\treturn new ZkLoginPublicIdentifier(tmp, options);\n}\n\nfunction normalizeZkLoginPublicKeyBytes(bytes: Uint8Array, legacyAddress = false) {\n\tconst issByteLength = bytes[0] + 1;\n\tconst addressSeed = BigInt(`0x${toHex(bytes.slice(issByteLength))}`);\n\tconst seedBytes = legacyAddress\n\t\t? toBigEndianBytes(addressSeed, 32)\n\t\t: toPaddedBigEndianBytes(addressSeed, 32);\n\tconst data = new Uint8Array(issByteLength + seedBytes.length);\n\tdata.set(bytes.slice(0, issByteLength), 0);\n\tdata.set(seedBytes, issByteLength);\n\treturn data;\n}\n\nasync function graphqlVerifyZkLoginSignature({\n\taddress,\n\tbytes,\n\tsignature,\n\tintentScope,\n\tclient = new HaneulGraphQLClient({\n\t\turl: 'https://graphql.mainnet.haneul.io/graphql',\n\t}),\n}: {\n\taddress: string;\n\tbytes: string;\n\tsignature: string;\n\tintentScope: 'PersonalMessage' | 'TransactionData';\n\tclient?: ZkLoginCompatibleClient;\n}) {\n\tconst resp = await client.core.verifyZkLoginSignature({\n\t\tbytes,\n\t\tsignature,\n\t\tintentScope,\n\t\tauthor: address,\n\t});\n\n\treturn resp.success === true && resp.errors.length === 0;\n}\n\nexport function parseSerializedZkLoginSignature(signature: Uint8Array | string) {\n\tconst bytes = typeof signature === 'string' ? fromBase64(signature) : signature;\n\n\tif (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.ZkLogin) {\n\t\tthrow new Error('Invalid signature scheme');\n\t}\n\n\tconst signatureBytes = bytes.slice(1);\n\tconst { inputs, maxEpoch, userSignature } = parseZkLoginSignature(signatureBytes);\n\tconst { issBase64Details, addressSeed } = inputs;\n\tconst iss = extractClaimValue<string>(issBase64Details, 'iss');\n\tconst publicIdentifer = toZkLoginPublicIdentifier(BigInt(addressSeed), iss);\n\treturn {\n\t\tserializedSignature: toBase64(bytes),\n\t\tsignatureScheme: 'ZkLogin' as const,\n\t\tzkLogin: {\n\t\t\tinputs,\n\t\t\tmaxEpoch,\n\t\t\tuserSignature,\n\t\t\tiss,\n\t\t\taddressSeed: BigInt(addressSeed),\n\t\t},\n\t\tsignature: bytes,\n\t\tpublicKey: publicIdentifer.toRawBytes(),\n\t};\n}\n"],
+  "mappings": "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",
+  "names": ["import_utils"]
+}

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

@@ -0,0 +1,23 @@
+import type { ZkLoginSignature } from './bcs.js';
+interface ZkLoginSignatureExtended extends Omit<ZkLoginSignature, 'userSignature'> {
+    userSignature: string | ZkLoginSignature['userSignature'];
+}
+export declare function getZkLoginSignature({ inputs, maxEpoch, userSignature }: ZkLoginSignatureExtended): string;
+export declare function parseZkLoginSignature(signature: string | Uint8Array): {
+    inputs: {
+        proofPoints: {
+            a: string[];
+            b: string[][];
+            c: string[];
+        };
+        issBase64Details: {
+            value: string;
+            indexMod4: number;
+        };
+        headerBase64: string;
+        addressSeed: string;
+    };
+    maxEpoch: string;
+    userSignature: Uint8Array<ArrayBufferLike>;
+};
+export {};

package/dist/cjs/zklogin/signature.js

@@ -0,0 +1,48 @@
+"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 signature_exports = {};
+__export(signature_exports, {
+  getZkLoginSignature: () => getZkLoginSignature,
+  parseZkLoginSignature: () => parseZkLoginSignature
+});
+module.exports = __toCommonJS(signature_exports);
+var import_bcs = require("@haneullabs/bcs");
+var import_signature_scheme = require("../cryptography/signature-scheme.js");
+var import_bcs2 = require("./bcs.js");
+function getZkLoginSignatureBytes({ inputs, maxEpoch, userSignature }) {
+  return import_bcs2.zkLoginSignature.serialize(
+    {
+      inputs,
+      maxEpoch,
+      userSignature: typeof userSignature === "string" ? (0, import_bcs.fromBase64)(userSignature) : userSignature
+    },
+    { maxSize: 2048 }
+  ).toBytes();
+}
+function getZkLoginSignature({ inputs, maxEpoch, userSignature }) {
+  const bytes = getZkLoginSignatureBytes({ inputs, maxEpoch, userSignature });
+  const signatureBytes = new Uint8Array(bytes.length + 1);
+  signatureBytes.set([import_signature_scheme.SIGNATURE_SCHEME_TO_FLAG.ZkLogin]);
+  signatureBytes.set(bytes, 1);
+  return (0, import_bcs.toBase64)(signatureBytes);
+}
+function parseZkLoginSignature(signature) {
+  return import_bcs2.zkLoginSignature.parse(typeof signature === "string" ? (0, import_bcs.fromBase64)(signature) : signature);
+}
+//# sourceMappingURL=signature.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/signature.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64 } from '@haneullabs/bcs';\n\nimport { SIGNATURE_SCHEME_TO_FLAG } from '../cryptography/signature-scheme.js';\nimport type { ZkLoginSignature } from './bcs.js';\nimport { zkLoginSignature } from './bcs.js';\n\ninterface ZkLoginSignatureExtended extends Omit<ZkLoginSignature, 'userSignature'> {\n\tuserSignature: string | ZkLoginSignature['userSignature'];\n}\n\nfunction getZkLoginSignatureBytes({ inputs, maxEpoch, userSignature }: ZkLoginSignatureExtended) {\n\treturn zkLoginSignature\n\t\t.serialize(\n\t\t\t{\n\t\t\t\tinputs,\n\t\t\t\tmaxEpoch,\n\t\t\t\tuserSignature:\n\t\t\t\t\ttypeof userSignature === 'string' ? fromBase64(userSignature) : userSignature,\n\t\t\t},\n\t\t\t{ maxSize: 2048 },\n\t\t)\n\t\t.toBytes();\n}\n\nexport function getZkLoginSignature({ inputs, maxEpoch, userSignature }: ZkLoginSignatureExtended) {\n\tconst bytes = getZkLoginSignatureBytes({ inputs, maxEpoch, userSignature });\n\tconst signatureBytes = new Uint8Array(bytes.length + 1);\n\tsignatureBytes.set([SIGNATURE_SCHEME_TO_FLAG.ZkLogin]);\n\tsignatureBytes.set(bytes, 1);\n\treturn toBase64(signatureBytes);\n}\n\nexport function parseZkLoginSignature(signature: string | Uint8Array) {\n\treturn zkLoginSignature.parse(typeof signature === 'string' ? fromBase64(signature) : signature);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAAqC;AAErC,8BAAyC;AAEzC,IAAAA,cAAiC;AAMjC,SAAS,yBAAyB,EAAE,QAAQ,UAAU,cAAc,GAA6B;AAChG,SAAO,6BACL;AAAA,IACA;AAAA,MACC;AAAA,MACA;AAAA,MACA,eACC,OAAO,kBAAkB,eAAW,uBAAW,aAAa,IAAI;AAAA,IAClE;AAAA,IACA,EAAE,SAAS,KAAK;AAAA,EACjB,EACC,QAAQ;AACX;AAEO,SAAS,oBAAoB,EAAE,QAAQ,UAAU,cAAc,GAA6B;AAClG,QAAM,QAAQ,yBAAyB,EAAE,QAAQ,UAAU,cAAc,CAAC;AAC1E,QAAM,iBAAiB,IAAI,WAAW,MAAM,SAAS,CAAC;AACtD,iBAAe,IAAI,CAAC,iDAAyB,OAAO,CAAC;AACrD,iBAAe,IAAI,OAAO,CAAC;AAC3B,aAAO,qBAAS,cAAc;AAC/B;AAEO,SAAS,sBAAsB,WAAgC;AACrE,SAAO,6BAAiB,MAAM,OAAO,cAAc,eAAW,uBAAW,SAAS,IAAI,SAAS;AAChG;",
+  "names": ["import_bcs"]
+}

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

@@ -0,0 +1,16 @@
+import type { PublicKey } from '../cryptography/publickey.js';
+export declare function toPaddedBigEndianBytes(num: bigint, width: number): Uint8Array;
+export declare function toBigEndianBytes(num: bigint, width: number): Uint8Array;
+export declare function getExtendedEphemeralPublicKey(publicKey: PublicKey): string;
+/**
+ * Splits an array into chunks of size chunk_size. If the array is not evenly
+ * divisible by chunk_size, the first chunk will be smaller than chunk_size.
+ *
+ * E.g., arrayChunk([1, 2, 3, 4, 5], 2) => [[1], [2, 3], [4, 5]]
+ *
+ * Note: Can be made more efficient by avoiding the reverse() calls.
+ */
+export declare function chunkArray<T>(array: T[], chunk_size: number): T[][];
+export declare function hashASCIIStrToField(str: string, maxSize: number): bigint;
+export declare function genAddressSeed(salt: string | bigint, name: string, value: string, aud: string, max_name_length?: number, max_value_length?: number, max_aud_length?: number): bigint;
+export declare function normalizeZkLoginIssuer(iss: string): string;

package/dist/cjs/zklogin/utils.js

@@ -0,0 +1,97 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  chunkArray: () => chunkArray,
+  genAddressSeed: () => genAddressSeed,
+  getExtendedEphemeralPublicKey: () => getExtendedEphemeralPublicKey,
+  hashASCIIStrToField: () => hashASCIIStrToField,
+  normalizeZkLoginIssuer: () => normalizeZkLoginIssuer,
+  toBigEndianBytes: () => toBigEndianBytes,
+  toPaddedBigEndianBytes: () => toPaddedBigEndianBytes
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("@noble/hashes/utils");
+var import_poseidon = require("./poseidon.js");
+const MAX_KEY_CLAIM_NAME_LENGTH = 32;
+const MAX_KEY_CLAIM_VALUE_LENGTH = 115;
+const MAX_AUD_VALUE_LENGTH = 145;
+const PACK_WIDTH = 248;
+function findFirstNonZeroIndex(bytes) {
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] !== 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function toPaddedBigEndianBytes(num, width) {
+  const hex = num.toString(16);
+  return (0, import_utils.hexToBytes)(hex.padStart(width * 2, "0").slice(-width * 2));
+}
+function toBigEndianBytes(num, width) {
+  const bytes = toPaddedBigEndianBytes(num, width);
+  const firstNonZeroIndex = findFirstNonZeroIndex(bytes);
+  if (firstNonZeroIndex === -1) {
+    return new Uint8Array([0]);
+  }
+  return bytes.slice(firstNonZeroIndex);
+}
+function getExtendedEphemeralPublicKey(publicKey) {
+  return publicKey.toHaneulPublicKey();
+}
+function chunkArray(array, chunk_size) {
+  const chunks = Array(Math.ceil(array.length / chunk_size));
+  const revArray = array.reverse();
+  for (let i = 0; i < chunks.length; i++) {
+    chunks[i] = revArray.slice(i * chunk_size, (i + 1) * chunk_size).reverse();
+  }
+  return chunks.reverse();
+}
+function bytesBEToBigInt(bytes) {
+  const hex = bytes.map((b) => b.toString(16).padStart(2, "0")).join("");
+  if (hex.length === 0) {
+    return BigInt(0);
+  }
+  return BigInt("0x" + hex);
+}
+function hashASCIIStrToField(str, maxSize) {
+  if (str.length > maxSize) {
+    throw new Error(`String ${str} is longer than ${maxSize} chars`);
+  }
+  const strPadded = str.padEnd(maxSize, String.fromCharCode(0)).split("").map((c) => c.charCodeAt(0));
+  const chunkSize = PACK_WIDTH / 8;
+  const packed = chunkArray(strPadded, chunkSize).map((chunk) => bytesBEToBigInt(chunk));
+  return (0, import_poseidon.poseidonHash)(packed);
+}
+function genAddressSeed(salt, name, value, aud, max_name_length = MAX_KEY_CLAIM_NAME_LENGTH, max_value_length = MAX_KEY_CLAIM_VALUE_LENGTH, max_aud_length = MAX_AUD_VALUE_LENGTH) {
+  return (0, import_poseidon.poseidonHash)([
+    hashASCIIStrToField(name, max_name_length),
+    hashASCIIStrToField(value, max_value_length),
+    hashASCIIStrToField(aud, max_aud_length),
+    (0, import_poseidon.poseidonHash)([BigInt(salt)])
+  ]);
+}
+function normalizeZkLoginIssuer(iss) {
+  if (iss === "accounts.google.com") {
+    return "https://accounts.google.com";
+  }
+  return iss;
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/zklogin/utils.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { hexToBytes } from '@noble/hashes/utils';\n\nimport type { PublicKey } from '../cryptography/publickey.js';\nimport { poseidonHash } from './poseidon.js';\n\nconst MAX_KEY_CLAIM_NAME_LENGTH = 32;\nconst MAX_KEY_CLAIM_VALUE_LENGTH = 115;\nconst MAX_AUD_VALUE_LENGTH = 145;\nconst PACK_WIDTH = 248;\n\nfunction findFirstNonZeroIndex(bytes: Uint8Array) {\n\tfor (let i = 0; i < bytes.length; i++) {\n\t\tif (bytes[i] !== 0) {\n\t\t\treturn i;\n\t\t}\n\t}\n\n\treturn -1;\n}\n\n// Derive bytearray from num where the bytearray is padded to the left with 0s to the specified width.\nexport function toPaddedBigEndianBytes(num: bigint, width: number): Uint8Array {\n\tconst hex = num.toString(16);\n\treturn hexToBytes(hex.padStart(width * 2, '0').slice(-width * 2));\n}\n\n// Derive bytearray from num where the bytearray is not padded with 0.\nexport function toBigEndianBytes(num: bigint, width: number): Uint8Array {\n\tconst bytes = toPaddedBigEndianBytes(num, width);\n\n\tconst firstNonZeroIndex = findFirstNonZeroIndex(bytes);\n\n\tif (firstNonZeroIndex === -1) {\n\t\treturn new Uint8Array([0]);\n\t}\n\n\treturn bytes.slice(firstNonZeroIndex);\n}\n\nexport function getExtendedEphemeralPublicKey(publicKey: PublicKey) {\n\treturn publicKey.toHaneulPublicKey();\n}\n\n/**\n * Splits an array into chunks of size chunk_size. If the array is not evenly\n * divisible by chunk_size, the first chunk will be smaller than chunk_size.\n *\n * E.g., arrayChunk([1, 2, 3, 4, 5], 2) => [[1], [2, 3], [4, 5]]\n *\n * Note: Can be made more efficient by avoiding the reverse() calls.\n */\nexport function chunkArray<T>(array: T[], chunk_size: number): T[][] {\n\tconst chunks = Array(Math.ceil(array.length / chunk_size));\n\tconst revArray = array.reverse();\n\tfor (let i = 0; i < chunks.length; i++) {\n\t\tchunks[i] = revArray.slice(i * chunk_size, (i + 1) * chunk_size).reverse();\n\t}\n\treturn chunks.reverse();\n}\n\nfunction bytesBEToBigInt(bytes: number[]): bigint {\n\tconst hex = bytes.map((b) => b.toString(16).padStart(2, '0')).join('');\n\tif (hex.length === 0) {\n\t\treturn BigInt(0);\n\t}\n\treturn BigInt('0x' + hex);\n}\n\n// hashes an ASCII string to a field element\nexport function hashASCIIStrToField(str: string, maxSize: number) {\n\tif (str.length > maxSize) {\n\t\tthrow new Error(`String ${str} is longer than ${maxSize} chars`);\n\t}\n\n\t// Note: Padding with zeroes is safe because we are only using this function to map human-readable sequence of bytes.\n\t// So the ASCII values of those characters will never be zero (null character).\n\tconst strPadded = str\n\t\t.padEnd(maxSize, String.fromCharCode(0))\n\t\t.split('')\n\t\t.map((c) => c.charCodeAt(0));\n\n\tconst chunkSize = PACK_WIDTH / 8;\n\tconst packed = chunkArray(strPadded, chunkSize).map((chunk) => bytesBEToBigInt(chunk));\n\treturn poseidonHash(packed);\n}\n\nexport function genAddressSeed(\n\tsalt: string | bigint,\n\tname: string,\n\tvalue: string,\n\taud: string,\n\tmax_name_length = MAX_KEY_CLAIM_NAME_LENGTH,\n\tmax_value_length = MAX_KEY_CLAIM_VALUE_LENGTH,\n\tmax_aud_length = MAX_AUD_VALUE_LENGTH,\n): bigint {\n\treturn poseidonHash([\n\t\thashASCIIStrToField(name, max_name_length),\n\t\thashASCIIStrToField(value, max_value_length),\n\t\thashASCIIStrToField(aud, max_aud_length),\n\t\tposeidonHash([BigInt(salt)]),\n\t]);\n}\n\nexport function normalizeZkLoginIssuer(iss: string) {\n\tif (iss === 'accounts.google.com') {\n\t\treturn 'https://accounts.google.com';\n\t}\n\treturn iss;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAA2B;AAG3B,sBAA6B;AAE7B,MAAM,4BAA4B;AAClC,MAAM,6BAA6B;AACnC,MAAM,uBAAuB;AAC7B,MAAM,aAAa;AAEnB,SAAS,sBAAsB,OAAmB;AACjD,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACtC,QAAI,MAAM,CAAC,MAAM,GAAG;AACnB,aAAO;AAAA,IACR;AAAA,EACD;AAEA,SAAO;AACR;AAGO,SAAS,uBAAuB,KAAa,OAA2B;AAC9E,QAAM,MAAM,IAAI,SAAS,EAAE;AAC3B,aAAO,yBAAW,IAAI,SAAS,QAAQ,GAAG,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;AACjE;AAGO,SAAS,iBAAiB,KAAa,OAA2B;AACxE,QAAM,QAAQ,uBAAuB,KAAK,KAAK;AAE/C,QAAM,oBAAoB,sBAAsB,KAAK;AAErD,MAAI,sBAAsB,IAAI;AAC7B,WAAO,IAAI,WAAW,CAAC,CAAC,CAAC;AAAA,EAC1B;AAEA,SAAO,MAAM,MAAM,iBAAiB;AACrC;AAEO,SAAS,8BAA8B,WAAsB;AACnE,SAAO,UAAU,kBAAkB;AACpC;AAUO,SAAS,WAAc,OAAY,YAA2B;AACpE,QAAM,SAAS,MAAM,KAAK,KAAK,MAAM,SAAS,UAAU,CAAC;AACzD,QAAM,WAAW,MAAM,QAAQ;AAC/B,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACvC,WAAO,CAAC,IAAI,SAAS,MAAM,IAAI,aAAa,IAAI,KAAK,UAAU,EAAE,QAAQ;AAAA,EAC1E;AACA,SAAO,OAAO,QAAQ;AACvB;AAEA,SAAS,gBAAgB,OAAyB;AACjD,QAAM,MAAM,MAAM,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AACrE,MAAI,IAAI,WAAW,GAAG;AACrB,WAAO,OAAO,CAAC;AAAA,EAChB;AACA,SAAO,OAAO,OAAO,GAAG;AACzB;AAGO,SAAS,oBAAoB,KAAa,SAAiB;AACjE,MAAI,IAAI,SAAS,SAAS;AACzB,UAAM,IAAI,MAAM,UAAU,GAAG,mBAAmB,OAAO,QAAQ;AAAA,EAChE;AAIA,QAAM,YAAY,IAChB,OAAO,SAAS,OAAO,aAAa,CAAC,CAAC,EACtC,MAAM,EAAE,EACR,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAE5B,QAAM,YAAY,aAAa;AAC/B,QAAM,SAAS,WAAW,WAAW,SAAS,EAAE,IAAI,CAAC,UAAU,gBAAgB,KAAK,CAAC;AACrF,aAAO,8BAAa,MAAM;AAC3B;AAEO,SAAS,eACf,MACA,MACA,OACA,KACA,kBAAkB,2BAClB,mBAAmB,4BACnB,iBAAiB,sBACR;AACT,aAAO,8BAAa;AAAA,IACnB,oBAAoB,MAAM,eAAe;AAAA,IACzC,oBAAoB,OAAO,gBAAgB;AAAA,IAC3C,oBAAoB,KAAK,cAAc;AAAA,QACvC,8BAAa,CAAC,OAAO,IAAI,CAAC,CAAC;AAAA,EAC5B,CAAC;AACF;AAEO,SAAS,uBAAuB,KAAa;AACnD,MAAI,QAAQ,uBAAuB;AAClC,WAAO;AAAA,EACR;AACA,SAAO;AACR;",
+  "names": []
+}