@layerzerolabs/lz-foundation 3.0.14 → 3.0.16

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @layerzerolabs/lz-foundation
 
+## 3.0.16
+
+### Patch Changes
+
+- 87a4bc9: islander mainnet
+- Updated dependencies [87a4bc9]
+  - @layerzerolabs/lz-definitions@3.0.16
+  - @layerzerolabs/lz-utilities@3.0.16
+
+## 3.0.15
+
+### Patch Changes
+
+- 67856bd: endpoints
+- Updated dependencies [67856bd]
+  - @layerzerolabs/lz-definitions@3.0.15
+  - @layerzerolabs/lz-utilities@3.0.15
+
 ## 3.0.14
 
 ### Patch Changes

package/README.md

@@ -1,3 +1,107 @@
-# layerzero-foundation
+# @layerzerolabs/lz-foundation
 
-This package contains functions, interfaces for chains inter-operability.
+The LayerZero Foundation package provides essential functions and interfaces for chain interoperability. It includes utilities for signing, hashing, and managing key pairs.
+
+## Features
+
+- **Address Utilities**: Functions for manipulating addresses of different chains.
+- **Base Utilities**: General-purpose utility functions.
+- **Signing**: Sign messages and transactions using different algorithms.
+- **Hashing**: Compute various cryptographic hashes.
+- **Key Management**: Generate and manage key pairs.
+
+## Installation
+
+To install the LayerZero Foundation package, you can use npm or yarn:
+
+```sh
+npm install @layerzerolabs/lz-foundation
+```
+
+or
+
+```sh
+yarn add @layerzerolabs/lz-foundation
+```
+
+## Usage
+
+### Address Utilities
+
+Gets the human-readable address.
+
+```typescript
+import { aptos } from "@layerzerolabs/lz-foundation"
+
+const address = "0x1234567890abcdef1234567890abcdef12345678"
+const addr = aptos.Address.from(address)
+const hr = addr.hr()
+console.log(`human-readable address: ${hr}`)
+```
+
+### Base Utilities
+
+Encodes a string or Uint8Array to a base58 string.
+
+```typescript
+import { base58 } from "@layerzerolabs/lz-foundation"
+
+const msg = "hello"
+const encode = base58.encode(msg)
+console.log(`base58 encoded message: ${encode}`)
+```
+
+### Hashing
+
+Computes the Keccak-256 hash of the given message.
+
+- message: The input message to hash.
+- Returns: The Keccak-256 hash of the input message.
+
+```typescript
+import { keccak_256 } from "@layerzerolabs/lz-foundation"
+
+const message = "Hello, world!"
+const hash = keccak_256(message)
+console.log(`Keccak-256 Hash: ${Buffer.from(hash).toString("hex")}`)
+```
+
+### Signing
+
+Signs a hash using the specified signing algorithm.
+
+- hash: The hash to sign, must be 32 bytes long.
+- privateKey: The private key in hex format or Uint8Array.
+- algorithm: The signing algorithm to use.
+- Returns: A promise that resolves to the signature.
+
+```typescript
+import { signHash, SignAlgorithm } from "@layerzerolabs/lz-foundation"
+
+const hash = new Uint8Array(32) // Example hash
+const privateKey = "0xYourPrivateKey"
+const algorithm = SignAlgorithm.SECP256K1
+
+signHash(hash, privateKey, algorithm).then((signature) => {
+  console.log(`Signature: ${Buffer.from(signature).toString("hex")}`)
+})
+```
+
+### Key Management
+
+Interface representing a key pair consisting of a private key and a public key.
+
+- privateKey: The private key as a Uint8Array.
+- publicKey: The public key as a Uint8Array.
+
+```typescript
+import { KeyPair } from "@layerzerolabs/lz-foundation"
+
+const keyPair: KeyPair = {
+  privateKey: new Uint8Array(32), // Example private key
+  publicKey: new Uint8Array(32), // Example public key
+}
+
+console.log(`Private Key: ${Buffer.from(keyPair.privateKey).toString("hex")}`)
+console.log(`Public Key: ${Buffer.from(keyPair.publicKey).toString("hex")}`)
+```

package/dist/index.cjs

@@ -5,6 +5,9 @@ var sha256 = require('@noble/hashes/sha256');
 var sha3 = require('@noble/hashes/sha3');
 var ed25519 = require('@noble/ed25519');
 var secp256k1 = require('@noble/secp256k1');
+var base = require('@scure/base');
+var lzUtilities = require('@layerzerolabs/lz-utilities');
+var lzDefinitions = require('@layerzerolabs/lz-definitions');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -33,7 +36,7 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 function keccak_256(message) {
-  return keccak_256();
+  return sha3.keccak_256(message);
 }
 function blake2b(message) {
   return blake2b$1.blake2b(message);
@@ -144,12 +147,26 @@ var Secp256k1Signer = class _Secp256k1Signer {
   constructor(privateKey) {
     this.privateKey = privateKey;
   }
+  /**
+   * Creates an instance of Secp256k1Signer from a private key.
+   * @param {Uint8Array} privateKey - The private key.
+   * @returns {Secp256k1Signer} The created Secp256k1Signer instance.
+   */
   static from(privatekey) {
     return new _Secp256k1Signer(privatekey);
   }
+  /**
+   * Returns the public key of the signer.
+   * @returns {Promise<Uint8Array>} A promise that resolves to the public key.
+   */
   async getPublicKey() {
     return secp256k1_exports.getPublicKey(this.privateKey);
   }
+  /**
+   * Signs a hash.
+   * @param {Uint8Array} hash - The hash to sign, must be 32 bytes long.
+   * @returns {Promise<Uint8Array>} A promise that resolves to the signature.
+   */
   async signHash(hash) {
     return secp256k1_exports.signHash(hash, this.privateKey);
   }
@@ -158,26 +175,435 @@ var Ed25519Signer = class _Ed25519Signer {
   constructor(privateKey) {
     this.privateKey = privateKey;
   }
+  /**
+   * Creates an instance of Ed25519Signer from a private key.
+   * @param {Uint8Array} privateKey - The private key.
+   * @returns {Ed25519Signer} The created Ed25519Signer instance.
+   */
   static from(privateKey) {
     return new _Ed25519Signer(privateKey);
   }
+  /**
+   * Signs a hash.
+   * @param {Uint8Array} hash - The hash to sign, must be 32 bytes long.
+   * @returns {Promise<Uint8Array>} A promise that resolves to the signature.
+   */
   async signHash(hash) {
     return ed25519_exports.signHash(hash, this.privateKey);
   }
+  /**
+   * Returns the public key of the signer.
+   * @returns {Promise<Uint8Array>} A promise that resolves to the public key.
+   */
   async getPublicKey() {
     return ed25519_exports.getPublicKey(this.privateKey);
   }
 };
 
+// src/base/base58.ts
+var base58_exports = {};
+__export(base58_exports, {
+  decode: () => decode,
+  encode: () => encode
+});
+function encode(value) {
+  if (typeof value === "string") {
+    return base.base58.encode(lzUtilities.arrayify(value));
+  } else {
+    return base.base58.encode(value);
+  }
+}
+function decode(value) {
+  return base.base58.decode(value);
+}
+
+// src/base/base58check.ts
+var base58check_exports = {};
+__export(base58check_exports, {
+  decode: () => decode2,
+  encode: () => encode2
+});
+function encode2(value) {
+  const base58check = base.createBase58check(sha256.sha256);
+  if (typeof value === "string") {
+    return base58check.encode(lzUtilities.arrayify(value));
+  } else {
+    return base58check.encode(value);
+  }
+}
+function decode2(value) {
+  const base58check = base.createBase58check(sha256.sha256);
+  return base58check.decode(value);
+}
+
+// src/base/base64.ts
+var base64_exports = {};
+__export(base64_exports, {
+  decode: () => decode3,
+  encode: () => encode3
+});
+function encode3(value) {
+  if (typeof value === "string") {
+    return base.base64.encode(lzUtilities.arrayify(value));
+  } else {
+    return base.base64.encode(value);
+  }
+}
+function decode3(value) {
+  return base.base64.decode(value);
+}
+
+// src/address/aptos.ts
+var aptos_exports = {};
+__export(aptos_exports, {
+  Address: () => Address
+});
+var Address = class _Address {
+  /**
+   * Creates an instance of Address.
+   * @param {Uint8Array | string} value - The address value.
+   * @throws {Error} If the address is invalid.
+   */
+  constructor(value) {
+    let data = void 0;
+    if (value instanceof Uint8Array) {
+      data = value;
+    } else if (typeof value === "string") {
+      if (lzUtilities.isHex(value)) {
+        data = lzUtilities.arrayify(value);
+      }
+    }
+    if (data === void 0) {
+      throw new Error("Invalid address");
+    }
+    if (data.length > 32) {
+      throw new Error("Invalid address length. Expected less or equal than 32 bytes.");
+    }
+    this.data = data;
+  }
+  /**
+   * Creates an Address instance from a value.
+   * @param {Uint8Array | string} value - The address value.
+   * @returns {Address} The Address instance.
+   */
+  static from(value) {
+    return new _Address(value);
+  }
+  /**
+   * Inspects the address.
+   * @returns {string} The address as a string.
+   */
+  inspect() {
+    return this.toString();
+  }
+  /**
+   * Converts the address to a string.
+   * @returns {string} The address as a string.
+   */
+  toString() {
+    return this.hr();
+  }
+  /**
+   * Gets the raw address data.
+   * @returns {Uint8Array} The raw address data.
+   */
+  raw() {
+    return this.data;
+  }
+  /**
+   * Gets the human-readable address.
+   * @returns {string} The human-readable address.
+   */
+  hr() {
+    return lzUtilities.hexlify(this.data);
+  }
+  /**
+   * Gets the address as a hexadecimal string.
+   * @returns {Hex} The address as a hexadecimal string.
+   */
+  hex() {
+    return lzUtilities.hexlify(this.data);
+  }
+};
+
+// src/address/evm.ts
+var evm_exports = {};
+__export(evm_exports, {
+  Address: () => Address2,
+  toChecksumAddress: () => toChecksumAddress
+});
+var Address2 = class _Address {
+  /**
+   * Creates an instance of Address.
+   * @param {Uint8Array | string} value - The address value.
+   * @throws {Error} If the address is invalid.
+   */
+  constructor(value) {
+    let data = void 0;
+    if (value instanceof Uint8Array) {
+      data = value;
+    } else if (typeof value === "string" && lzUtilities.isHex(value)) {
+      data = lzUtilities.arrayify(value);
+    }
+    if (data === void 0) {
+      throw new Error("Invalid address");
+    }
+    if (data.length > 20) {
+      const prefix = data.slice(0, data.length - 20);
+      const isAllZero = prefix.every((byte) => byte === 0);
+      if (!isAllZero) {
+        throw new Error("Invalid address length. Expected less or equal than 20 bytes.");
+      }
+    }
+    this.data = data;
+  }
+  /**
+   * Creates an Address instance from a value.
+   * @param {Uint8Array | string} value - The address value.
+   * @returns {Address} The Address instance.
+   */
+  static from(value) {
+    return new _Address(value);
+  }
+  /**
+   * Inspects the address.
+   * @returns {string} The address as a string.
+   */
+  inspect() {
+    return this.toString();
+  }
+  /**
+   * Converts the address to a string.
+   * @returns {string} The address as a string.
+   */
+  toString() {
+    return this.hr();
+  }
+  /**
+   * Gets the raw address data.
+   * @returns {Uint8Array} The raw address data.
+   */
+  raw() {
+    return this.data;
+  }
+  /**
+   * Gets the human-readable address.
+   * @returns {string} The human-readable address.
+   */
+  hr() {
+    const value = lzUtilities.hexlify(lzUtilities.padify(this.data, { size: 20 }));
+    return toChecksumAddress(value);
+  }
+  /**
+   * Gets the address as a hexadecimal string.
+   * @returns {Hex} The address as a hexadecimal string.
+   */
+  hex() {
+    return lzUtilities.hexlify(lzUtilities.padify(this.data, { size: 20 }));
+  }
+};
+function toChecksumAddress(address) {
+  const lowercasedAddress = address.toLowerCase().replace("0x", "");
+  const hash = Buffer.from(keccak_256(lowercasedAddress)).toString("hex");
+  let checksumAddress = "0x";
+  for (let i = 0; i < lowercasedAddress.length; i++) {
+    if (parseInt(hash[i], 16) > 7) {
+      checksumAddress += lowercasedAddress[i].toUpperCase();
+    } else {
+      checksumAddress += lowercasedAddress[i];
+    }
+  }
+  return checksumAddress;
+}
+
+// src/address/solana.ts
+var solana_exports = {};
+__export(solana_exports, {
+  Address: () => Address3
+});
+var Address3 = class _Address {
+  /**
+   * Creates an instance of Address.
+   * @param {Uint8Array | string} value - The address value.
+   * @throws {Error} If the address is invalid.
+   */
+  constructor(value) {
+    let data = void 0;
+    if (value instanceof Uint8Array) {
+      data = value;
+    } else if (typeof value === "string") {
+      if (lzUtilities.isHex(value)) {
+        data = lzUtilities.arrayify(value);
+      } else {
+        data = base58_exports.decode(value);
+      }
+    }
+    if (data === void 0) {
+      throw new Error("Invalid address");
+    }
+    if (data.length > 32) {
+      throw new Error("Invalid address length. Expected less or equal than 32 bytes.");
+    }
+    this.data = data;
+  }
+  /**
+   * Creates an Address instance from a value.
+   * @param {Uint8Array | string} value - The address value.
+   * @returns {Address} The Address instance.
+   */
+  static from(value) {
+    return new _Address(value);
+  }
+  /**
+   * Inspects the address.
+   * @returns {string} The address as a string.
+   */
+  inspect() {
+    return this.toString();
+  }
+  /**
+   * Converts the address to a string.
+   * @returns {string} The address as a string.
+   */
+  toString() {
+    return this.hr();
+  }
+  /**
+   * Gets the raw address data.
+   * @returns {Uint8Array} The raw address data.
+   */
+  raw() {
+    return this.data;
+  }
+  /**
+   * Gets the human-readable address.
+   * @returns {string} The human-readable address.
+   */
+  hr() {
+    return base58_exports.encode(this.data);
+  }
+  /**
+   * Gets the address as a hexadecimal string.
+   * @returns {Hex} The address as a hexadecimal string.
+   */
+  hex() {
+    return lzUtilities.hexlify(this.data);
+  }
+};
+
+// src/address/tron.ts
+var tron_exports = {};
+__export(tron_exports, {
+  Address: () => Address4
+});
+var Address4 = class _Address {
+  /**
+   * Creates an instance of Address.
+   * @param {Uint8Array | string} value - The address value.
+   * @throws {Error} If the address is invalid.
+   */
+  constructor(value) {
+    let data = void 0;
+    if (value instanceof Uint8Array) {
+      data = value;
+    } else if (typeof value === "string") {
+      if (lzUtilities.isHex(value)) {
+        data = lzUtilities.arrayify(value);
+      } else {
+        data = base58check_exports.decode(value);
+      }
+    }
+    if (data === void 0) {
+      throw new Error("Invalid address");
+    }
+    if (data.length != 21) {
+      throw new Error("Invalid address length. Expected 21 bytes.");
+    }
+    this.data = data;
+  }
+  /**
+   * Creates an Address instance from a value.
+   * @param {Uint8Array | string} value - The address value.
+   * @returns {Address} The Address instance.
+   */
+  static from(value) {
+    return new _Address(value);
+  }
+  /**
+   * Inspects the address.
+   * @returns {string} The address as a string.
+   */
+  inspect() {
+    return this.toString();
+  }
+  /**
+   * Converts the address to a string.
+   * @returns {string} The address as a string.
+   */
+  toString() {
+    return this.hr();
+  }
+  /**
+   * Gets the raw address data.
+   * @returns {Uint8Array} The raw address data.
+   */
+  raw() {
+    return this.data;
+  }
+  /**
+   * Gets the human-readable address.
+   * @returns {string} The human-readable address.
+   */
+  hr() {
+    return base58check_exports.encode(this.data);
+  }
+  /**
+   * Gets the address as a hexadecimal string.
+   * @returns {Hex} The address as a hexadecimal string.
+   */
+  hex() {
+    return lzUtilities.hexlify(this.data);
+  }
+};
+var Address5 = {
+  from: (address, chain) => {
+    const chainType = lzDefinitions.chainToChainType(chain);
+    switch (chainType) {
+      case lzDefinitions.ChainType.EVM:
+        if (chain === lzDefinitions.Chain.TRON) {
+          return Address4.from(address);
+        }
+        return Address2.from(address);
+      case lzDefinitions.ChainType.APTOS:
+        return Address.from(address);
+      case lzDefinitions.ChainType.SOLANA:
+        return Address3.from(address);
+      default:
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }
+  }
+};
+
+// src/address/address.ts
+var Address6 = Address5;
+
+exports.Address = Address6;
 exports.Ed25519Signer = Ed25519Signer;
 exports.Secp256k1Signer = Secp256k1Signer;
 exports.SignAlgorithm = SignAlgorithm;
+exports.aptos = aptos_exports;
+exports.base58 = base58_exports;
+exports.base58check = base58check_exports;
+exports.base64 = base64_exports;
 exports.blake2b = blake2b;
 exports.ed25519 = ed25519_exports;
+exports.evm = evm_exports;
 exports.keccak_256 = keccak_256;
 exports.secp256k1 = secp256k1_exports;
 exports.sha2_256 = sha2_256;
 exports.sha3_256 = sha3_256;
 exports.signHash = signHash3;
+exports.solana = solana_exports;
+exports.tron = tron_exports;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map