@layerzerolabs/lz-foundation 3.0.3 → 3.0.5

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @layerzerolabs/lz-foundation
 
+## 3.0.5
+
+### Patch Changes
+
+- 1136853: endpoint: mainnet worldchain
+- Updated dependencies [1136853]
+  - @layerzerolabs/lz-definitions@3.0.5
+  - @layerzerolabs/lz-utilities@3.0.5
+
+## 3.0.4
+
+### Patch Changes
+
+- 4b060b6: testnets
+- Updated dependencies [4b060b6]
+  - @layerzerolabs/lz-definitions@3.0.4
+  - @layerzerolabs/lz-utilities@3.0.4
+
 ## 3.0.3
 
 ### Patch Changes

package/dist/index.cjs

@@ -139,6 +139,38 @@ async function signHash3(hash, privateKey, algorithm) {
   }
 }
 
+// src/signer.ts
+var Secp256k1Signer = class _Secp256k1Signer {
+  constructor(privateKey) {
+    this.privateKey = privateKey;
+  }
+  static from(privatekey) {
+    return new _Secp256k1Signer(privatekey);
+  }
+  async getPublicKey() {
+    return secp256k1_exports.getPublicKey(this.privateKey);
+  }
+  async signHash(hash) {
+    return secp256k1_exports.signHash(hash, this.privateKey);
+  }
+};
+var Ed25519Signer = class _Ed25519Signer {
+  constructor(privateKey) {
+    this.privateKey = privateKey;
+  }
+  static from(privateKey) {
+    return new _Ed25519Signer(privateKey);
+  }
+  async signHash(hash) {
+    return ed25519_exports.signHash(hash, this.privateKey);
+  }
+  async getPublicKey() {
+    return ed25519_exports.getPublicKey(this.privateKey);
+  }
+};
+
+exports.Ed25519Signer = Ed25519Signer;
+exports.Secp256k1Signer = Secp256k1Signer;
 exports.SignAlgorithm = SignAlgorithm;
 exports.blake2b = blake2b;
 exports.ed25519 = ed25519_exports;

package/dist/index.cjs.map

@@ -1 +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"]}
+{"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","../src/signer.ts"],"names":["SignAlgorithm","getPublicKey","signHash"],"mappings":"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","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","import { ed25519, secp256k1 } from './sign'\n/**\n * Interface for signing a hash.\n */\nexport interface HashSigner {\n    /**\n     * signHash signs a hash\n     * @param hash - 32 bytes long\n     */\n    signHash(hash: Uint8Array): Promise<Uint8Array>\n\n    /**\n     * publicKey returns the public key of the signer\n     */\n    getPublicKey(): Promise<Uint8Array>\n}\n\nexport class Secp256k1Signer implements HashSigner {\n    private constructor(private readonly privateKey: Uint8Array) {}\n\n    static from(privatekey: Uint8Array): Secp256k1Signer {\n        return new Secp256k1Signer(privatekey)\n    }\n\n    async getPublicKey(): Promise<Uint8Array> {\n        return secp256k1.getPublicKey(this.privateKey)\n    }\n\n    async signHash(hash: Uint8Array): Promise<Uint8Array> {\n        return secp256k1.signHash(hash, this.privateKey)\n    }\n}\n\nexport class Ed25519Signer implements HashSigner {\n    private constructor(private readonly privateKey: Uint8Array) {}\n\n    static from(privateKey: Uint8Array): Ed25519Signer {\n        return new Ed25519Signer(privateKey)\n    }\n\n    async signHash(hash: Uint8Array): Promise<Uint8Array> {\n        return ed25519.signHash(hash, this.privateKey)\n    }\n\n    async getPublicKey(): Promise<Uint8Array> {\n        return ed25519.getPublicKey(this.privateKey)\n    }\n}\n"]}

package/dist/index.d.mts

@@ -43,4 +43,33 @@ declare namespace secp256k1 {
 
 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 };
+/**
+ * Interface for signing a hash.
+ */
+interface HashSigner {
+    /**
+     * signHash signs a hash
+     * @param hash - 32 bytes long
+     */
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
+    /**
+     * publicKey returns the public key of the signer
+     */
+    getPublicKey(): Promise<Uint8Array>;
+}
+declare class Secp256k1Signer implements HashSigner {
+    private readonly privateKey;
+    private constructor();
+    static from(privatekey: Uint8Array): Secp256k1Signer;
+    getPublicKey(): Promise<Uint8Array>;
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
+}
+declare class Ed25519Signer implements HashSigner {
+    private readonly privateKey;
+    private constructor();
+    static from(privateKey: Uint8Array): Ed25519Signer;
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
+    getPublicKey(): Promise<Uint8Array>;
+}
+
+export { Ed25519Signer, type HashSigner, type KeyPair, Secp256k1Signer, SignAlgorithm, blake2b, ed25519, keccak_256, secp256k1, sha2_256, sha3_256, signHash };

package/dist/index.d.ts

@@ -43,4 +43,33 @@ declare namespace secp256k1 {
 
 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 };
+/**
+ * Interface for signing a hash.
+ */
+interface HashSigner {
+    /**
+     * signHash signs a hash
+     * @param hash - 32 bytes long
+     */
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
+    /**
+     * publicKey returns the public key of the signer
+     */
+    getPublicKey(): Promise<Uint8Array>;
+}
+declare class Secp256k1Signer implements HashSigner {
+    private readonly privateKey;
+    private constructor();
+    static from(privatekey: Uint8Array): Secp256k1Signer;
+    getPublicKey(): Promise<Uint8Array>;
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
+}
+declare class Ed25519Signer implements HashSigner {
+    private readonly privateKey;
+    private constructor();
+    static from(privateKey: Uint8Array): Ed25519Signer;
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
+    getPublicKey(): Promise<Uint8Array>;
+}
+
+export { Ed25519Signer, type HashSigner, type KeyPair, Secp256k1Signer, SignAlgorithm, blake2b, ed25519, keccak_256, secp256k1, sha2_256, sha3_256, signHash };

package/dist/index.mjs

@@ -116,6 +116,36 @@ async function signHash3(hash, privateKey, algorithm) {
   }
 }
 
-export { SignAlgorithm, blake2b, ed25519_exports as ed25519, keccak_256, secp256k1_exports as secp256k1, sha2_256, sha3_256, signHash3 as signHash };
+// src/signer.ts
+var Secp256k1Signer = class _Secp256k1Signer {
+  constructor(privateKey) {
+    this.privateKey = privateKey;
+  }
+  static from(privatekey) {
+    return new _Secp256k1Signer(privatekey);
+  }
+  async getPublicKey() {
+    return secp256k1_exports.getPublicKey(this.privateKey);
+  }
+  async signHash(hash) {
+    return secp256k1_exports.signHash(hash, this.privateKey);
+  }
+};
+var Ed25519Signer = class _Ed25519Signer {
+  constructor(privateKey) {
+    this.privateKey = privateKey;
+  }
+  static from(privateKey) {
+    return new _Ed25519Signer(privateKey);
+  }
+  async signHash(hash) {
+    return ed25519_exports.signHash(hash, this.privateKey);
+  }
+  async getPublicKey() {
+    return ed25519_exports.getPublicKey(this.privateKey);
+  }
+};
+
+export { Ed25519Signer, Secp256k1Signer, 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

@@ -1 +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"]}
+{"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","../src/signer.ts"],"names":["SignAlgorithm","getPublicKey","signHash"],"mappings":"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","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","import { ed25519, secp256k1 } from './sign'\n/**\n * Interface for signing a hash.\n */\nexport interface HashSigner {\n    /**\n     * signHash signs a hash\n     * @param hash - 32 bytes long\n     */\n    signHash(hash: Uint8Array): Promise<Uint8Array>\n\n    /**\n     * publicKey returns the public key of the signer\n     */\n    getPublicKey(): Promise<Uint8Array>\n}\n\nexport class Secp256k1Signer implements HashSigner {\n    private constructor(private readonly privateKey: Uint8Array) {}\n\n    static from(privatekey: Uint8Array): Secp256k1Signer {\n        return new Secp256k1Signer(privatekey)\n    }\n\n    async getPublicKey(): Promise<Uint8Array> {\n        return secp256k1.getPublicKey(this.privateKey)\n    }\n\n    async signHash(hash: Uint8Array): Promise<Uint8Array> {\n        return secp256k1.signHash(hash, this.privateKey)\n    }\n}\n\nexport class Ed25519Signer implements HashSigner {\n    private constructor(private readonly privateKey: Uint8Array) {}\n\n    static from(privateKey: Uint8Array): Ed25519Signer {\n        return new Ed25519Signer(privateKey)\n    }\n\n    async signHash(hash: Uint8Array): Promise<Uint8Array> {\n        return ed25519.signHash(hash, this.privateKey)\n    }\n\n    async getPublicKey(): Promise<Uint8Array> {\n        return ed25519.getPublicKey(this.privateKey)\n    }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/lz-foundation",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "description": "LayerZero Core Library",
   "license": "BUSL-1.1",
   "exports": {
@@ -23,16 +23,16 @@
     "clean-prebuild": "rimraf dist"
   },
   "dependencies": {
-    "@layerzerolabs/lz-definitions": "^3.0.3",
-    "@layerzerolabs/lz-utilities": "^3.0.3",
+    "@layerzerolabs/lz-definitions": "^3.0.5",
+    "@layerzerolabs/lz-utilities": "^3.0.5",
     "@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": "^3.0.3",
-    "@layerzerolabs/typescript-config-next": "^3.0.3",
+    "@layerzerolabs/tsup-config-next": "^3.0.5",
+    "@layerzerolabs/typescript-config-next": "^3.0.5",
     "@types/jest": "^29.5.10",
     "jest": "^29.7.0",
     "rimraf": "^5.0.5",