@layerzerolabs/lz-foundation 2.3.30-oft-rc.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @layerzerolabs/lz-foundation
+
+## 2.3.30-oft-rc.0
+
+### Patch Changes
+
+- 7d63aa8: test
+- Updated dependencies [7d63aa8]
+  - @layerzerolabs/lz-definitions@2.3.45-oft-rc.0
+  - @layerzerolabs/lz-utilities@2.3.45-oft-rc.0

package/README.md

@@ -0,0 +1,3 @@
+# layerzero-foundation
+
+This package contains functions, interfaces for chains inter-operability.

package/dist/index.cjs

@@ -0,0 +1,151 @@
+'use strict';
+
+var blake2b$1 = require('@noble/hashes/blake2b');
+var sha256 = require('@noble/hashes/sha256');
+var sha3 = require('@noble/hashes/sha3');
+var ed25519 = require('@noble/ed25519');
+var secp256k1 = require('@noble/secp256k1');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ed25519__namespace = /*#__PURE__*/_interopNamespace(ed25519);
+var secp256k1__namespace = /*#__PURE__*/_interopNamespace(secp256k1);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function keccak_256(message) {
+  return keccak_256();
+}
+function blake2b(message) {
+  return blake2b$1.blake2b(message);
+}
+function sha3_256(message) {
+  return sha3.sha3_256(message);
+}
+function sha2_256(message) {
+  return sha256.sha256(message);
+}
+
+// src/sign/constant.ts
+var SignAlgorithm = /* @__PURE__ */ ((SignAlgorithm2) => {
+  SignAlgorithm2[SignAlgorithm2["NATIVE"] = 0] = "NATIVE";
+  SignAlgorithm2[SignAlgorithm2["SECP256K1"] = 1] = "SECP256K1";
+  SignAlgorithm2[SignAlgorithm2["ED25519"] = 2] = "ED25519";
+  return SignAlgorithm2;
+})(SignAlgorithm || {});
+
+// src/sign/ed25519.ts
+var ed25519_exports = {};
+__export(ed25519_exports, {
+  getPublicKey: () => getPublicKey2,
+  signHash: () => signHash
+});
+
+// src/sign/internal.ts
+function normalizePrivateKey(privateKey) {
+  if (typeof privateKey === "string") {
+    return privateKey.replace(/^0x/, "");
+  } else if (typeof privateKey === "bigint") {
+    return privateKey.toString(16).padStart(64, "0");
+  } else {
+    return privateKey;
+  }
+}
+
+// src/sign/ed25519.ts
+async function signHash(hash, privateKey) {
+  if (hash.length !== 32) {
+    throw new Error("Hash must be 32 bytes long");
+  }
+  privateKey = normalizePrivateKey(privateKey);
+  const pubKey = await ed25519__namespace.getPublicKey(privateKey);
+  const signature = await ed25519__namespace.sign(hash, privateKey);
+  const isValid = await ed25519__namespace.verify(signature, hash, pubKey);
+  if (!isValid) {
+    throw new Error("Invalid signature");
+  }
+  return signature;
+}
+async function getPublicKey2(privateKey) {
+  privateKey = normalizePrivateKey(privateKey);
+  return ed25519__namespace.getPublicKey(privateKey);
+}
+
+// src/sign/secp256k1.ts
+var secp256k1_exports = {};
+__export(secp256k1_exports, {
+  getPublicKey: () => getPublicKey4,
+  signHash: () => signHash2
+});
+async function signHash2(hash, privateKey) {
+  if (hash.length !== 32) {
+    throw new Error("Hash must be 32 bytes long");
+  }
+  privateKey = normalizePrivateKey(privateKey);
+  const pubKey = secp256k1__namespace.getPublicKey(privateKey, false);
+  const [signature, recoveryId] = await secp256k1__namespace.sign(hash, privateKey, {
+    // recovered - true indicates the recovered bit should be included in the result
+    recovered: true,
+    // canonical - true makes signatures compatible with libsecp256k1, false makes signatures compatible with openssl
+    canonical: true,
+    // der - whether the returned signature should be in DER format. If false, it would be in Compact format (32-byte r + 32-byte s)
+    der: false,
+    // extraEntropy - When true, it would automatically be filled with 32 bytes of cryptographically secure entropy. Strongly recommended to pass true to improve security:
+    extraEntropy: void 0
+  });
+  const isValid = secp256k1__namespace.verify(signature, hash, pubKey, { strict: true });
+  if (!isValid) {
+    throw new Error("Invalid signature");
+  }
+  return Uint8Array.from([...signature, recoveryId]);
+}
+async function getPublicKey4(privateKey) {
+  privateKey = normalizePrivateKey(privateKey);
+  return Promise.resolve(secp256k1__namespace.getPublicKey(privateKey, false));
+}
+
+// src/sign/index.ts
+async function signHash3(hash, privateKey, algorithm) {
+  if (hash.length !== 32) {
+    throw new Error("Hash must be 32 bytes long");
+  }
+  const privKey = typeof privateKey === "string" ? privateKey.replace(/^0x/, "") : Buffer.from(privateKey).toString("hex");
+  switch (algorithm) {
+    case 1 /* SECP256K1 */:
+      return signHash2(hash, privKey);
+    case 2 /* ED25519 */:
+      return signHash(hash, privKey);
+    default:
+      throw new Error(`Unsupported algorithm: ${algorithm}`);
+  }
+}
+
+exports.SignAlgorithm = SignAlgorithm;
+exports.blake2b = blake2b;
+exports.ed25519 = ed25519_exports;
+exports.keccak_256 = keccak_256;
+exports.secp256k1 = secp256k1_exports;
+exports.sha2_256 = sha2_256;
+exports.sha3_256 = sha3_256;
+exports.signHash = signHash3;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hash/index.ts","../src/sign/constant.ts","../src/sign/ed25519.ts","../src/sign/internal.ts","../src/sign/secp256k1.ts","../src/sign/index.ts"],"names":["SignAlgorithm","getPublicKey","signHash"],"mappings":";;;;;;;AAAA,SAAS,WAAW,gBAAgB;AACpC,SAAS,UAAU,eAAe;AAClC,SAAS,YAAY,iBAAiB;AAE/B,SAAS,WAAW,SAA0C;AACjE,SAAO,WAAW,OAAO;AAC7B;AAEO,SAAS,QAAQ,SAA0C;AAC9D,SAAO,SAAS,OAAO;AAC3B;AAEO,SAAS,SAAS,SAA0C;AAC/D,SAAO,UAAU,OAAO;AAC5B;AAEO,SAAS,SAAS,SAA0C;AAC/D,SAAO,QAAQ,OAAO;AAC1B;;;AClBO,IAAK,gBAAL,kBAAKA,mBAAL;AACH,EAAAA,8BAAA;AACA,EAAAA,8BAAA;AACA,EAAAA,8BAAA;AAHQ,SAAAA;AAAA,GAAA;;;ACAZ;AAAA;AAAA,sBAAAC;AAAA,EAAA;AAAA;AAAA,YAAY,aAAa;;;ACMlB,SAAS,oBAAoB,YAA+D;AAC/F,MAAI,OAAO,eAAe,UAAU;AAChC,WAAO,WAAW,QAAQ,OAAO,EAAE;AAAA,EACvC,WAAW,OAAO,eAAe,UAAU;AACvC,WAAO,WAAW,SAAS,EAAE,EAAE,SAAS,IAAI,GAAG;AAAA,EACnD,OAAO;AACH,WAAO;AAAA,EACX;AACJ;;;ADJA,eAAsB,SAAS,MAAkB,YAA+D;AAC5G,MAAI,KAAK,WAAW,IAAI;AACpB,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAChD;AAEA,eAAa,oBAAoB,UAAU;AAC3C,QAAM,SAAS,MAAc,qBAAa,UAAU;AACpD,QAAM,YAAY,MAAc,aAAK,MAAM,UAAU;AACrD,QAAM,UAAU,MAAc,eAAO,WAAW,MAAM,MAAM;AAC5D,MAAI,CAAC,SAAS;AACV,UAAM,IAAI,MAAM,mBAAmB;AAAA,EACvC;AAEA,SAAO;AACX;AAEA,eAAsBA,cAAa,YAA+D;AAC9F,eAAa,oBAAoB,UAAU;AAC3C,SAAe,qBAAa,UAAU;AAC1C;;;AE7BA;AAAA;AAAA,sBAAAA;AAAA,EAAA,gBAAAC;AAAA;AAAA,YAAY,eAAe;AAU3B,eAAsBA,UAAS,MAAkB,YAA+D;AAC5G,MAAI,KAAK,WAAW,IAAI;AACpB,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAChD;AAEA,eAAa,oBAAoB,UAAU;AAC3C,QAAM,SAAmB,uBAAa,YAAY,KAAK;AAGvD,QAAM,CAAC,WAAW,UAAU,IAAI,MAAgB,eAAK,MAAM,YAAY;AAAA;AAAA,IAEnE,WAAW;AAAA;AAAA,IAEX,WAAW;AAAA;AAAA,IAEX,KAAK;AAAA;AAAA,IAEL,cAAc;AAAA,EAClB,CAAC;AAED,QAAM,UAAoB,iBAAO,WAAW,MAAM,QAAQ,EAAE,QAAQ,KAAK,CAAC;AAC1E,MAAI,CAAC,SAAS;AACV,UAAM,IAAI,MAAM,mBAAmB;AAAA,EACvC;AAEA,SAAO,WAAW,KAAK,CAAC,GAAG,WAAW,UAAU,CAAC;AACrD;AAEA,eAAsBD,cAAa,YAA+D;AAC9F,eAAa,oBAAoB,UAAU;AAC3C,SAAO,QAAQ,QAAkB,uBAAa,YAAY,KAAK,CAAC;AACpE;;;ACnCA,eAAsBC,UAClB,MACA,YACA,WACmB;AACnB,MAAI,KAAK,WAAW,IAAI;AACpB,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAChD;AAIA,QAAM,UACF,OAAO,eAAe,WAAW,WAAW,QAAQ,OAAO,EAAE,IAAI,OAAO,KAAK,UAAU,EAAE,SAAS,KAAK;AAC3G,UAAQ,WAAW;AAAA,IACf;AACI,aAAiBA,UAAS,MAAM,OAAO;AACvC;AAAA,IACJ;AACI,aAAe,SAAS,MAAM,OAAO;AACrC;AAAA,IACJ;AACI,YAAM,IAAI,MAAM,0BAA0B,SAAS,EAAE;AAAA,EAC7D;AACJ","sourcesContent":["import { blake2b as _blake2b } from '@noble/hashes/blake2b'\nimport { sha256 as _sha256 } from '@noble/hashes/sha256'\nimport { sha3_256 as _sha3_256 } from '@noble/hashes/sha3'\n\nexport function keccak_256(message: Uint8Array | string): Uint8Array {\n    return keccak_256(message)\n}\n\nexport function blake2b(message: Uint8Array | string): Uint8Array {\n    return _blake2b(message)\n}\n\nexport function sha3_256(message: Uint8Array | string): Uint8Array {\n    return _sha3_256(message)\n}\n\nexport function sha2_256(message: Uint8Array | string): Uint8Array {\n    return _sha256(message)\n}\n","export enum SignAlgorithm {\n    NATIVE,\n    SECP256K1,\n    ED25519,\n}\n","import * as ed25519 from '@noble/ed25519'\n\nimport { normalizePrivateKey } from './internal'\n\n/**\n * Sign a hash using ed25519\n * @param hash - 32 bytes long\n * @param privateKey - private key in hex format\n * @returns\n */\nexport async function signHash(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    if (hash.length !== 32) {\n        throw new Error('Hash must be 32 bytes long')\n    }\n\n    privateKey = normalizePrivateKey(privateKey)\n    const pubKey = await ed25519.getPublicKey(privateKey)\n    const signature = await ed25519.sign(hash, privateKey)\n    const isValid = await ed25519.verify(signature, hash, pubKey)\n    if (!isValid) {\n        throw new Error('Invalid signature')\n    }\n\n    return signature\n}\n\nexport async function getPublicKey(privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    privateKey = normalizePrivateKey(privateKey)\n    return ed25519.getPublicKey(privateKey)\n}\n","/**\n * Normalize the private key to a string or Uint8Array\n * - getPublicKey accepts bigint but sign does not, in ed25519\n * - a string privateKey should not have a 0x prefix, in ed25519\n * @param privateKey\n */\nexport function normalizePrivateKey(privateKey: string | Uint8Array | bigint): string | Uint8Array {\n    if (typeof privateKey === 'string') {\n        return privateKey.replace(/^0x/, '')\n    } else if (typeof privateKey === 'bigint') {\n        return privateKey.toString(16).padStart(64, '0') // the private key is 32 bytes for ed25519 and secp256k1\n    } else {\n        return privateKey\n    }\n}\n","import * as secp256k1 from '@noble/secp256k1'\n\nimport { normalizePrivateKey } from './internal'\n\n/**\n * Sign a hash using secp256k1\n * @param hash - 32 bytes long\n * @param privateKey - private key in hex format\n * @returns\n */\nexport async function signHash(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    if (hash.length !== 32) {\n        throw new Error('Hash must be 32 bytes long')\n    }\n\n    privateKey = normalizePrivateKey(privateKey)\n    const pubKey = secp256k1.getPublicKey(privateKey, false)\n\n    // refer to: https://github.com/paulmillr/noble-secp256k1/tree/1.7.1#signmsghash-privatekey\n    const [signature, recoveryId] = await secp256k1.sign(hash, privateKey, {\n        // recovered - true indicates the recovered bit should be included in the result\n        recovered: true,\n        // canonical - true makes signatures compatible with libsecp256k1, false makes signatures compatible with openssl\n        canonical: true,\n        // der - whether the returned signature should be in DER format. If false, it would be in Compact format (32-byte r + 32-byte s)\n        der: false,\n        // extraEntropy - When true, it would automatically be filled with 32 bytes of cryptographically secure entropy. Strongly recommended to pass true to improve security:\n        extraEntropy: undefined,\n    })\n\n    const isValid = secp256k1.verify(signature, hash, pubKey, { strict: true })\n    if (!isValid) {\n        throw new Error('Invalid signature')\n    }\n\n    return Uint8Array.from([...signature, recoveryId])\n}\n\nexport async function getPublicKey(privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    privateKey = normalizePrivateKey(privateKey)\n    return Promise.resolve(secp256k1.getPublicKey(privateKey, false))\n}\n","import { SignAlgorithm } from './constant'\nexport * from './keypair'\nexport * from './constant'\nimport * as ed25519 from './ed25519'\nimport * as secp256k1 from './secp256k1'\n\nexport async function signHash(\n    hash: Uint8Array,\n    privateKey: string | Uint8Array,\n    algorithm: SignAlgorithm\n): Promise<Uint8Array> {\n    if (hash.length !== 32) {\n        throw new Error('Hash must be 32 bytes long')\n    }\n\n    // privKey should be a hex string without 0x prefix\n    // refer to: https://github.com/paulmillr/noble-secp256k1/blob/5ed251242bf065aeb22a54bb42eee1f67e7c77ce/index.ts#L130\n    const privKey =\n        typeof privateKey === 'string' ? privateKey.replace(/^0x/, '') : Buffer.from(privateKey).toString('hex')\n    switch (algorithm) {\n        case SignAlgorithm.SECP256K1:\n            return secp256k1.signHash(hash, privKey)\n            break\n        case SignAlgorithm.ED25519:\n            return ed25519.signHash(hash, privKey)\n            break\n        default:\n            throw new Error(`Unsupported algorithm: ${algorithm}`)\n    }\n}\n\nexport { secp256k1, ed25519 }\n"]}

package/dist/index.d.mts

@@ -0,0 +1,46 @@
+declare function keccak_256(message: Uint8Array | string): Uint8Array;
+declare function blake2b(message: Uint8Array | string): Uint8Array;
+declare function sha3_256(message: Uint8Array | string): Uint8Array;
+declare function sha2_256(message: Uint8Array | string): Uint8Array;
+
+declare enum SignAlgorithm {
+    NATIVE = 0,
+    SECP256K1 = 1,
+    ED25519 = 2
+}
+
+interface KeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+
+/**
+ * Sign a hash using ed25519
+ * @param hash - 32 bytes long
+ * @param privateKey - private key in hex format
+ * @returns
+ */
+declare function signHash$2(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+declare function getPublicKey$1(privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+
+declare namespace ed25519 {
+  export { getPublicKey$1 as getPublicKey, signHash$2 as signHash };
+}
+
+/**
+ * Sign a hash using secp256k1
+ * @param hash - 32 bytes long
+ * @param privateKey - private key in hex format
+ * @returns
+ */
+declare function signHash$1(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+declare function getPublicKey(privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+
+declare const secp256k1_getPublicKey: typeof getPublicKey;
+declare namespace secp256k1 {
+  export { secp256k1_getPublicKey as getPublicKey, signHash$1 as signHash };
+}
+
+declare function signHash(hash: Uint8Array, privateKey: string | Uint8Array, algorithm: SignAlgorithm): Promise<Uint8Array>;
+
+export { type KeyPair, SignAlgorithm, blake2b, ed25519, keccak_256, secp256k1, sha2_256, sha3_256, signHash };

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+declare function keccak_256(message: Uint8Array | string): Uint8Array;
+declare function blake2b(message: Uint8Array | string): Uint8Array;
+declare function sha3_256(message: Uint8Array | string): Uint8Array;
+declare function sha2_256(message: Uint8Array | string): Uint8Array;
+
+declare enum SignAlgorithm {
+    NATIVE = 0,
+    SECP256K1 = 1,
+    ED25519 = 2
+}
+
+interface KeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+
+/**
+ * Sign a hash using ed25519
+ * @param hash - 32 bytes long
+ * @param privateKey - private key in hex format
+ * @returns
+ */
+declare function signHash$2(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+declare function getPublicKey$1(privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+
+declare namespace ed25519 {
+  export { getPublicKey$1 as getPublicKey, signHash$2 as signHash };
+}
+
+/**
+ * Sign a hash using secp256k1
+ * @param hash - 32 bytes long
+ * @param privateKey - private key in hex format
+ * @returns
+ */
+declare function signHash$1(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+declare function getPublicKey(privateKey: string | Uint8Array | bigint): Promise<Uint8Array>;
+
+declare const secp256k1_getPublicKey: typeof getPublicKey;
+declare namespace secp256k1 {
+  export { secp256k1_getPublicKey as getPublicKey, signHash$1 as signHash };
+}
+
+declare function signHash(hash: Uint8Array, privateKey: string | Uint8Array, algorithm: SignAlgorithm): Promise<Uint8Array>;
+
+export { type KeyPair, SignAlgorithm, blake2b, ed25519, keccak_256, secp256k1, sha2_256, sha3_256, signHash };

package/dist/index.mjs

@@ -0,0 +1,121 @@
+import { blake2b as blake2b$1 } from '@noble/hashes/blake2b';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha3_256 as sha3_256$1 } from '@noble/hashes/sha3';
+import * as ed25519 from '@noble/ed25519';
+import * as secp256k1 from '@noble/secp256k1';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function keccak_256(message) {
+  return keccak_256();
+}
+function blake2b(message) {
+  return blake2b$1(message);
+}
+function sha3_256(message) {
+  return sha3_256$1(message);
+}
+function sha2_256(message) {
+  return sha256(message);
+}
+
+// src/sign/constant.ts
+var SignAlgorithm = /* @__PURE__ */ ((SignAlgorithm2) => {
+  SignAlgorithm2[SignAlgorithm2["NATIVE"] = 0] = "NATIVE";
+  SignAlgorithm2[SignAlgorithm2["SECP256K1"] = 1] = "SECP256K1";
+  SignAlgorithm2[SignAlgorithm2["ED25519"] = 2] = "ED25519";
+  return SignAlgorithm2;
+})(SignAlgorithm || {});
+
+// src/sign/ed25519.ts
+var ed25519_exports = {};
+__export(ed25519_exports, {
+  getPublicKey: () => getPublicKey2,
+  signHash: () => signHash
+});
+
+// src/sign/internal.ts
+function normalizePrivateKey(privateKey) {
+  if (typeof privateKey === "string") {
+    return privateKey.replace(/^0x/, "");
+  } else if (typeof privateKey === "bigint") {
+    return privateKey.toString(16).padStart(64, "0");
+  } else {
+    return privateKey;
+  }
+}
+
+// src/sign/ed25519.ts
+async function signHash(hash, privateKey) {
+  if (hash.length !== 32) {
+    throw new Error("Hash must be 32 bytes long");
+  }
+  privateKey = normalizePrivateKey(privateKey);
+  const pubKey = await ed25519.getPublicKey(privateKey);
+  const signature = await ed25519.sign(hash, privateKey);
+  const isValid = await ed25519.verify(signature, hash, pubKey);
+  if (!isValid) {
+    throw new Error("Invalid signature");
+  }
+  return signature;
+}
+async function getPublicKey2(privateKey) {
+  privateKey = normalizePrivateKey(privateKey);
+  return ed25519.getPublicKey(privateKey);
+}
+
+// src/sign/secp256k1.ts
+var secp256k1_exports = {};
+__export(secp256k1_exports, {
+  getPublicKey: () => getPublicKey4,
+  signHash: () => signHash2
+});
+async function signHash2(hash, privateKey) {
+  if (hash.length !== 32) {
+    throw new Error("Hash must be 32 bytes long");
+  }
+  privateKey = normalizePrivateKey(privateKey);
+  const pubKey = secp256k1.getPublicKey(privateKey, false);
+  const [signature, recoveryId] = await secp256k1.sign(hash, privateKey, {
+    // recovered - true indicates the recovered bit should be included in the result
+    recovered: true,
+    // canonical - true makes signatures compatible with libsecp256k1, false makes signatures compatible with openssl
+    canonical: true,
+    // der - whether the returned signature should be in DER format. If false, it would be in Compact format (32-byte r + 32-byte s)
+    der: false,
+    // extraEntropy - When true, it would automatically be filled with 32 bytes of cryptographically secure entropy. Strongly recommended to pass true to improve security:
+    extraEntropy: void 0
+  });
+  const isValid = secp256k1.verify(signature, hash, pubKey, { strict: true });
+  if (!isValid) {
+    throw new Error("Invalid signature");
+  }
+  return Uint8Array.from([...signature, recoveryId]);
+}
+async function getPublicKey4(privateKey) {
+  privateKey = normalizePrivateKey(privateKey);
+  return Promise.resolve(secp256k1.getPublicKey(privateKey, false));
+}
+
+// src/sign/index.ts
+async function signHash3(hash, privateKey, algorithm) {
+  if (hash.length !== 32) {
+    throw new Error("Hash must be 32 bytes long");
+  }
+  const privKey = typeof privateKey === "string" ? privateKey.replace(/^0x/, "") : Buffer.from(privateKey).toString("hex");
+  switch (algorithm) {
+    case 1 /* SECP256K1 */:
+      return signHash2(hash, privKey);
+    case 2 /* ED25519 */:
+      return signHash(hash, privKey);
+    default:
+      throw new Error(`Unsupported algorithm: ${algorithm}`);
+  }
+}
+
+export { SignAlgorithm, blake2b, ed25519_exports as ed25519, keccak_256, secp256k1_exports as secp256k1, sha2_256, sha3_256, signHash3 as signHash };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hash/index.ts","../src/sign/constant.ts","../src/sign/ed25519.ts","../src/sign/internal.ts","../src/sign/secp256k1.ts","../src/sign/index.ts"],"names":["SignAlgorithm","getPublicKey","signHash"],"mappings":";;;;;;;AAAA,SAAS,WAAW,gBAAgB;AACpC,SAAS,UAAU,eAAe;AAClC,SAAS,YAAY,iBAAiB;AAE/B,SAAS,WAAW,SAA0C;AACjE,SAAO,WAAW,OAAO;AAC7B;AAEO,SAAS,QAAQ,SAA0C;AAC9D,SAAO,SAAS,OAAO;AAC3B;AAEO,SAAS,SAAS,SAA0C;AAC/D,SAAO,UAAU,OAAO;AAC5B;AAEO,SAAS,SAAS,SAA0C;AAC/D,SAAO,QAAQ,OAAO;AAC1B;;;AClBO,IAAK,gBAAL,kBAAKA,mBAAL;AACH,EAAAA,8BAAA;AACA,EAAAA,8BAAA;AACA,EAAAA,8BAAA;AAHQ,SAAAA;AAAA,GAAA;;;ACAZ;AAAA;AAAA,sBAAAC;AAAA,EAAA;AAAA;AAAA,YAAY,aAAa;;;ACMlB,SAAS,oBAAoB,YAA+D;AAC/F,MAAI,OAAO,eAAe,UAAU;AAChC,WAAO,WAAW,QAAQ,OAAO,EAAE;AAAA,EACvC,WAAW,OAAO,eAAe,UAAU;AACvC,WAAO,WAAW,SAAS,EAAE,EAAE,SAAS,IAAI,GAAG;AAAA,EACnD,OAAO;AACH,WAAO;AAAA,EACX;AACJ;;;ADJA,eAAsB,SAAS,MAAkB,YAA+D;AAC5G,MAAI,KAAK,WAAW,IAAI;AACpB,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAChD;AAEA,eAAa,oBAAoB,UAAU;AAC3C,QAAM,SAAS,MAAc,qBAAa,UAAU;AACpD,QAAM,YAAY,MAAc,aAAK,MAAM,UAAU;AACrD,QAAM,UAAU,MAAc,eAAO,WAAW,MAAM,MAAM;AAC5D,MAAI,CAAC,SAAS;AACV,UAAM,IAAI,MAAM,mBAAmB;AAAA,EACvC;AAEA,SAAO;AACX;AAEA,eAAsBA,cAAa,YAA+D;AAC9F,eAAa,oBAAoB,UAAU;AAC3C,SAAe,qBAAa,UAAU;AAC1C;;;AE7BA;AAAA;AAAA,sBAAAA;AAAA,EAAA,gBAAAC;AAAA;AAAA,YAAY,eAAe;AAU3B,eAAsBA,UAAS,MAAkB,YAA+D;AAC5G,MAAI,KAAK,WAAW,IAAI;AACpB,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAChD;AAEA,eAAa,oBAAoB,UAAU;AAC3C,QAAM,SAAmB,uBAAa,YAAY,KAAK;AAGvD,QAAM,CAAC,WAAW,UAAU,IAAI,MAAgB,eAAK,MAAM,YAAY;AAAA;AAAA,IAEnE,WAAW;AAAA;AAAA,IAEX,WAAW;AAAA;AAAA,IAEX,KAAK;AAAA;AAAA,IAEL,cAAc;AAAA,EAClB,CAAC;AAED,QAAM,UAAoB,iBAAO,WAAW,MAAM,QAAQ,EAAE,QAAQ,KAAK,CAAC;AAC1E,MAAI,CAAC,SAAS;AACV,UAAM,IAAI,MAAM,mBAAmB;AAAA,EACvC;AAEA,SAAO,WAAW,KAAK,CAAC,GAAG,WAAW,UAAU,CAAC;AACrD;AAEA,eAAsBD,cAAa,YAA+D;AAC9F,eAAa,oBAAoB,UAAU;AAC3C,SAAO,QAAQ,QAAkB,uBAAa,YAAY,KAAK,CAAC;AACpE;;;ACnCA,eAAsBC,UAClB,MACA,YACA,WACmB;AACnB,MAAI,KAAK,WAAW,IAAI;AACpB,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAChD;AAIA,QAAM,UACF,OAAO,eAAe,WAAW,WAAW,QAAQ,OAAO,EAAE,IAAI,OAAO,KAAK,UAAU,EAAE,SAAS,KAAK;AAC3G,UAAQ,WAAW;AAAA,IACf;AACI,aAAiBA,UAAS,MAAM,OAAO;AACvC;AAAA,IACJ;AACI,aAAe,SAAS,MAAM,OAAO;AACrC;AAAA,IACJ;AACI,YAAM,IAAI,MAAM,0BAA0B,SAAS,EAAE;AAAA,EAC7D;AACJ","sourcesContent":["import { blake2b as _blake2b } from '@noble/hashes/blake2b'\nimport { sha256 as _sha256 } from '@noble/hashes/sha256'\nimport { sha3_256 as _sha3_256 } from '@noble/hashes/sha3'\n\nexport function keccak_256(message: Uint8Array | string): Uint8Array {\n    return keccak_256(message)\n}\n\nexport function blake2b(message: Uint8Array | string): Uint8Array {\n    return _blake2b(message)\n}\n\nexport function sha3_256(message: Uint8Array | string): Uint8Array {\n    return _sha3_256(message)\n}\n\nexport function sha2_256(message: Uint8Array | string): Uint8Array {\n    return _sha256(message)\n}\n","export enum SignAlgorithm {\n    NATIVE,\n    SECP256K1,\n    ED25519,\n}\n","import * as ed25519 from '@noble/ed25519'\n\nimport { normalizePrivateKey } from './internal'\n\n/**\n * Sign a hash using ed25519\n * @param hash - 32 bytes long\n * @param privateKey - private key in hex format\n * @returns\n */\nexport async function signHash(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    if (hash.length !== 32) {\n        throw new Error('Hash must be 32 bytes long')\n    }\n\n    privateKey = normalizePrivateKey(privateKey)\n    const pubKey = await ed25519.getPublicKey(privateKey)\n    const signature = await ed25519.sign(hash, privateKey)\n    const isValid = await ed25519.verify(signature, hash, pubKey)\n    if (!isValid) {\n        throw new Error('Invalid signature')\n    }\n\n    return signature\n}\n\nexport async function getPublicKey(privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    privateKey = normalizePrivateKey(privateKey)\n    return ed25519.getPublicKey(privateKey)\n}\n","/**\n * Normalize the private key to a string or Uint8Array\n * - getPublicKey accepts bigint but sign does not, in ed25519\n * - a string privateKey should not have a 0x prefix, in ed25519\n * @param privateKey\n */\nexport function normalizePrivateKey(privateKey: string | Uint8Array | bigint): string | Uint8Array {\n    if (typeof privateKey === 'string') {\n        return privateKey.replace(/^0x/, '')\n    } else if (typeof privateKey === 'bigint') {\n        return privateKey.toString(16).padStart(64, '0') // the private key is 32 bytes for ed25519 and secp256k1\n    } else {\n        return privateKey\n    }\n}\n","import * as secp256k1 from '@noble/secp256k1'\n\nimport { normalizePrivateKey } from './internal'\n\n/**\n * Sign a hash using secp256k1\n * @param hash - 32 bytes long\n * @param privateKey - private key in hex format\n * @returns\n */\nexport async function signHash(hash: Uint8Array, privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    if (hash.length !== 32) {\n        throw new Error('Hash must be 32 bytes long')\n    }\n\n    privateKey = normalizePrivateKey(privateKey)\n    const pubKey = secp256k1.getPublicKey(privateKey, false)\n\n    // refer to: https://github.com/paulmillr/noble-secp256k1/tree/1.7.1#signmsghash-privatekey\n    const [signature, recoveryId] = await secp256k1.sign(hash, privateKey, {\n        // recovered - true indicates the recovered bit should be included in the result\n        recovered: true,\n        // canonical - true makes signatures compatible with libsecp256k1, false makes signatures compatible with openssl\n        canonical: true,\n        // der - whether the returned signature should be in DER format. If false, it would be in Compact format (32-byte r + 32-byte s)\n        der: false,\n        // extraEntropy - When true, it would automatically be filled with 32 bytes of cryptographically secure entropy. Strongly recommended to pass true to improve security:\n        extraEntropy: undefined,\n    })\n\n    const isValid = secp256k1.verify(signature, hash, pubKey, { strict: true })\n    if (!isValid) {\n        throw new Error('Invalid signature')\n    }\n\n    return Uint8Array.from([...signature, recoveryId])\n}\n\nexport async function getPublicKey(privateKey: string | Uint8Array | bigint): Promise<Uint8Array> {\n    privateKey = normalizePrivateKey(privateKey)\n    return Promise.resolve(secp256k1.getPublicKey(privateKey, false))\n}\n","import { SignAlgorithm } from './constant'\nexport * from './keypair'\nexport * from './constant'\nimport * as ed25519 from './ed25519'\nimport * as secp256k1 from './secp256k1'\n\nexport async function signHash(\n    hash: Uint8Array,\n    privateKey: string | Uint8Array,\n    algorithm: SignAlgorithm\n): Promise<Uint8Array> {\n    if (hash.length !== 32) {\n        throw new Error('Hash must be 32 bytes long')\n    }\n\n    // privKey should be a hex string without 0x prefix\n    // refer to: https://github.com/paulmillr/noble-secp256k1/blob/5ed251242bf065aeb22a54bb42eee1f67e7c77ce/index.ts#L130\n    const privKey =\n        typeof privateKey === 'string' ? privateKey.replace(/^0x/, '') : Buffer.from(privateKey).toString('hex')\n    switch (algorithm) {\n        case SignAlgorithm.SECP256K1:\n            return secp256k1.signHash(hash, privKey)\n            break\n        case SignAlgorithm.ED25519:\n            return ed25519.signHash(hash, privKey)\n            break\n        default:\n            throw new Error(`Unsupported algorithm: ${algorithm}`)\n    }\n}\n\nexport { secp256k1, ed25519 }\n"]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@layerzerolabs/lz-foundation",
+  "version": "2.3.30-oft-rc.0",
+  "description": "LayerZero Core Library",
+  "license": "BUSL-1.1",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "$npm_execpath clean-prebuild && $npm_execpath build-ts",
+    "build-ts": "$npm_execpath tsc --noEmit && $npm_execpath tsup",
+    "clean": "$npm_execpath clean-prebuild && rimraf .turbo",
+    "clean-prebuild": "rimraf dist"
+  },
+  "dependencies": {
+    "@layerzerolabs/lz-definitions": "^2.3.45-oft-rc.0",
+    "@layerzerolabs/lz-utilities": "^2.3.45-oft-rc.0",
+    "@noble/ed25519": "^1.7.1",
+    "@noble/hashes": "^1.3.2",
+    "@noble/secp256k1": "^1.7.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@layerzerolabs/tsup-config-next": "^2.3.45-oft-rc.0",
+    "@layerzerolabs/typescript-config-next": "^2.3.45-oft-rc.0",
+    "@types/jest": "^29.5.10",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.1",
+    "tsup": "^8.0.1",
+    "typescript": "~5.2.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}