@biglup/cometa 1.0.1 → 1.0.3

package/README.md

@@ -8,34 +8,51 @@
 
 <div align="center">
 
-[![Static Badge](https://img.shields.io/badge/Metric-Val-06f50?logoColor=ffffff)]()
-[![Static Badge](https://img.shields.io/badge/Metric-Val-06f50?logoColor=ffffff)]()
-[![Static Badge](https://img.shields.io/badge/Metric-Val-06f50?logoColor=ffffff)]()
-[![Static Badge](https://img.shields.io/badge/Metric-Val-06f50?logoColor=ffffff)]()
-[![Static Badge](https://img.shields.io/badge/Metric-Val-06f50?logoColor=ffffff)]()
+![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)
+![Post-Integration](https://github.com/Biglup/cometa.js/actions/workflows/unit-test.yml/badge.svg)
+![node-current](https://img.shields.io/node/v/@biglup/cometa)
+[![Documentation Status](https://app.readthedocs.org/projects/cometajs/badge/?version=latest)](https://cometajs.readthedocs.io/en/latest/?badge=latest)
+[![Twitter Follow](https://img.shields.io/twitter/follow/BiglupLabs?style=social)](https://x.com/BiglupLabs)
 
 </div>
 
 <hr>
 
-Cometa .JS is ....
+Cometa.js is a lightweight, high-performance JavaScript library binding for the [libcardano-c](https://github.com/Biglup/cardano-c) Library, designed to simplify blockchain development on Cardano.
 
+It embeds the WASM module directly into a single JavaScript file, ensuring a minimal footprint, fast performance, and effortless setup without requiring special server configurations.
+
+Built on the foundation of [libcardano-c](https://github.com/Biglup/cardano-c), Cometa.js inherits its commercial-grade quality, rigorous testing, and adherence to strict standards. It is ideal for developing reliable and secure solutions for mission-critical blockchain applications.
 <hr>
 
-- [Official Website]()
-- [Installation]()
-- [Documentation]()
+- [Official Website](https://cometa.dev/)
+- [Installation](#installation)
+- [Documentation](https://cometajs.readthedocs.io/en/latest/?badge=latest)
 
 <hr>
 
-### **TBD**
+### **Installation**
 
-<hr>
+To install Cometa.js on your project, use the following command:
 
-### **TBD**
+```bash
+yarn add @biglup/cometa
+```
 
 <hr>
 
-### **TBD**
+### **Building and Testing**
+
+To build and run the tests, use the following commands:
+
+```bash
+yarn install
+yarn build
+yarn test
+```
 
 <hr>
+
+### **License**
+
+Cometa.js is licensed under the Apache 2.0 License. See the [LICENSE](LICENSE) file for more information.

package/dist/cjs/index.d.mts

@@ -1,9 +1,162 @@
 declare const getLibCardanoCVersion: () => string;
+declare const hexToUint8Array: (hexString: string) => Uint8Array;
+declare const uint8ArrayToHex: (byteArray: Uint8Array) => string;
+declare const utf8ToUint8Array: (str: string) => Uint8Array;
+declare const uint8ArrayToUtf8: (uint8Array: Uint8Array) => string;
 
 declare const ready: () => Promise<void>;
 declare const getModule: () => any;
 declare const isReady: () => boolean;
 
+declare enum AddressType {
+    BasePaymentKeyStakeKey = 0,
+    BasePaymentScriptStakeKey = 1,
+    BasePaymentKeyStakeScript = 2,
+    BasePaymentScriptStakeScript = 3,
+    PointerKey = 4,
+    PointerScript = 5,
+    EnterpriseKey = 6,
+    EnterpriseScript = 7,
+    Byron = 8,
+    RewardKey = 14,
+    RewardScript = 15
+}
+
+declare enum CredentialType {
+    KeyHash = 0,
+    ScriptHash = 1
+}
+
+type Credential = {
+    hash: string;
+    type: CredentialType;
+};
+
+declare enum NetworkId {
+    Testnet = 0,
+    Mainnet = 1
+}
+
+declare class BaseAddress {
+    ptr: number;
+    constructor(ptr: number);
+    static fromCredentials(networkId: NetworkId, payment: Credential, stake: Credential): BaseAddress;
+    static fromAddress(address: Address): BaseAddress;
+    static fromBytes(data: Uint8Array): BaseAddress;
+    static fromBech32(data: string): BaseAddress;
+    toAddress(): Address;
+    getPaymentCredential(): Credential;
+    getStakeCredential(): Credential;
+    getNetworkId(): NetworkId;
+    toBytes(): Uint8Array;
+    toBech32(): string;
+    refCount(): number;
+}
+
+interface ByronAddressAttributes {
+    derivationPath: string;
+    magic: number;
+}
+
+declare enum ByronAddressType {
+    PubKey = 0,
+    Script = 1,
+    Redeem = 2
+}
+
+declare class ByronAddress {
+    ptr: number;
+    constructor(ptr: number);
+    static fromCredentials(root: string, attributes: ByronAddressAttributes, type: ByronAddressType): ByronAddress;
+    static fromAddress(address: Address): ByronAddress;
+    static fromBytes(bytes: Uint8Array): ByronAddress;
+    static fromBase58(base58: string): ByronAddress;
+    toAddress(): Address;
+    getAttributes(): ByronAddressAttributes;
+    getType(): ByronAddressType;
+    getRoot(): string;
+    getBytes(): Uint8Array;
+    toBase58(): string;
+    getNetworkId(): NetworkId;
+    refCount(): number;
+}
+
+declare class EnterpriseAddress {
+    ptr: number;
+    constructor(ptr: number);
+    static fromCredentials(networkId: NetworkId, payment: Credential): EnterpriseAddress;
+    static fromAddress(address: Address): EnterpriseAddress;
+    static fromBytes(data: Uint8Array): EnterpriseAddress;
+    static fromBech32(data: string): EnterpriseAddress;
+    toAddress(): Address;
+    getCredential(): Credential;
+    getNetworkId(): NetworkId;
+    toBytes(): Uint8Array;
+    toBech32(): string;
+    refCount(): number;
+}
+
+interface StakePointer {
+    slot: bigint;
+    txIndex: number;
+    certIndex: number;
+}
+
+declare class PointerAddress {
+    ptr: number;
+    constructor(ptr: number);
+    static fromCredentials(networkId: NetworkId, payment: Credential, stakePointer: StakePointer): PointerAddress;
+    static fromAddress(address: Address): PointerAddress;
+    static fromBytes(data: Uint8Array): PointerAddress;
+    static fromBech32(data: string): PointerAddress;
+    toAddress(): Address;
+    getPaymentCredential(): Credential;
+    getStakePointer(): StakePointer;
+    getNetworkId(): NetworkId;
+    toBytes(): Uint8Array;
+    toBech32(): string;
+    refCount(): number;
+}
+
+declare class RewardAddress {
+    ptr: number;
+    constructor(ptr: number);
+    static fromCredentials(networkId: NetworkId, stake: Credential): RewardAddress;
+    static fromAddress(address: Address): RewardAddress;
+    static fromBytes(data: Uint8Array): RewardAddress;
+    static fromBech32(data: string): RewardAddress;
+    toAddress(): Address;
+    getCredential(): Credential;
+    getNetworkId(): NetworkId;
+    toBytes(): Uint8Array;
+    toBech32(): string;
+    refCount(): number;
+}
+
+declare class Address {
+    ptr: number;
+    constructor(ptr: number);
+    static fromBytes(data: Uint8Array): Address;
+    static fromHex(hex: string): Address;
+    static fromString(address: string): Address;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toString(): string;
+    refCount(): number;
+    static isValidBech32(bech32: string): boolean;
+    static isValidByron(byron: string): boolean;
+    static isValid(address: string): boolean;
+    getType(): AddressType;
+    getNetworkId(): NetworkId;
+    asBase(): BaseAddress | null;
+    asEnterprise(): EnterpriseAddress | null;
+    asPointer(): PointerAddress | null;
+    asReward(): RewardAddress | null;
+    asByron(): ByronAddress | null;
+    private getBytesSize;
+    private getStringSize;
+}
+
 declare enum CborMajorType {
     UnsignedInteger = 0,
     NegativeInteger = 1,
@@ -122,20 +275,153 @@ declare class CborWriter {
     getRefCount(): number;
 }
 
+declare class Base58 {
+    private constructor();
+    static encode(data: Uint8Array): string;
+    static decode(encodedString: string): Uint8Array;
+    static encodeFromHex(hexString: string): string;
+    static decodeFromHex(base58String: string): string;
+    private static getEncodedLength;
+    private static getDecodedLength;
+}
+
+type Bech32DecodeResult = {
+    hrp: string;
+    data: Uint8Array;
+    hex: string;
+};
+declare class Bech32 {
+    private constructor();
+    static encode(hrp: string, data: Uint8Array): string;
+    static encodeFromHex(hrp: string, data: string): string;
+    static decode(encodedString: string): Bech32DecodeResult;
+    private static getEncodedLength;
+    private static getDecodedLength;
+}
+
 declare const finalizationRegistry: FinalizationRegistry<{
     ptr: any;
     freeFunc: any;
 }>;
 
-declare class ProtocolVersion {
+declare class Crc32 {
+    private constructor();
+    static compute(data: Uint8Array): number;
+    static computeFromHex(hexString: string): number;
+    static computeFromUtf8(data: string): number;
+}
+
+declare class Pbkdf2HmacSha512 {
+    private constructor();
+    static compute(password: Uint8Array, salt: Uint8Array, iterations: number, derivedKeyLength: number): Uint8Array;
+}
+
+declare class Emip003 {
+    static encrypt(data: Uint8Array, passphrase: Uint8Array): Uint8Array;
+    static decrypt(encryptedData: Uint8Array, passphrase: Uint8Array): Uint8Array;
+}
+
+declare class Blake2b {
+    private constructor();
+    static computeHash(data: Uint8Array, hashLength: number): Uint8Array;
+}
+
+declare class Ed25519Signature {
     ptr: number;
-    constructor(major: number, minor: number);
-    static fromCbor(reader: CborReader): ProtocolVersion;
-    toCbor(writer: CborWriter): void;
-    getMajor(): number;
-    setMajor(major: number): void;
-    getMinor(): number;
-    setMinor(minor: number): void;
+    constructor(ptr: number);
+    static fromBytes(data: Uint8Array): Ed25519Signature;
+    static fromHex(hex: string): Ed25519Signature;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    refCount(): number;
+    private getBytesSize;
+    private getHexSize;
 }
 
-export { CborMajorType, CborReader, CborReaderState, CborSimpleValue, CborTag, CborWriter, ProtocolVersion, finalizationRegistry, getLibCardanoCVersion, getModule, isReady, ready };
+declare class Ed25519PublicKey {
+    ptr: number;
+    constructor(ptr: number);
+    static fromBytes(data: Uint8Array): Ed25519PublicKey;
+    static fromHex(hex: string): Ed25519PublicKey;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    verify(signature: Ed25519Signature, message: Uint8Array): boolean;
+    toHash(): Uint8Array;
+    toHashHex(): string;
+    refCount(): number;
+    private getBytesSize;
+    private getHexSize;
+}
+
+declare class Bip32PublicKey {
+    ptr: number;
+    constructor(ptr: number);
+    static fromBytes(data: Uint8Array): Bip32PublicKey;
+    static fromHex(hex: string): Bip32PublicKey;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    derive(indices: number[]): Bip32PublicKey;
+    toEd25519Key(): Ed25519PublicKey;
+    toHash(): Uint8Array;
+    toHashHex(): string;
+    refCount(): number;
+    private getBytesSize;
+    private getHexSize;
+}
+
+declare class Ed25519PrivateKey {
+    ptr: number;
+    constructor(ptr: number);
+    static fromNormalBytes(data: Uint8Array): Ed25519PrivateKey;
+    static fromExtendedBytes(data: Uint8Array): Ed25519PrivateKey;
+    static fromNormalHex(hex: string): Ed25519PrivateKey;
+    static fromExtendedHex(hex: string): Ed25519PrivateKey;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    sign(message: Uint8Array): Ed25519Signature;
+    getPublicKey(): Ed25519PublicKey;
+    refCount(): number;
+    private getBytesSize;
+    private getHexSize;
+}
+
+declare class Bip32PrivateKey {
+    ptr: number;
+    private constructor();
+    static fromBip39Entropy(password: Uint8Array, entropy: Uint8Array): Bip32PrivateKey;
+    static fromBytes(data: Uint8Array): Bip32PrivateKey;
+    static fromHex(hex: string): Bip32PrivateKey;
+    derive(indices: number[]): Bip32PrivateKey;
+    getPublicKey(): Bip32PublicKey;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toEd25519Key(): Ed25519PrivateKey;
+    refCount(): number;
+    private getBytesSize;
+}
+
+declare const writeStringToMemory: (str: string) => number;
+declare const getErrorString: (error: number) => string;
+
+declare const MIN_SIGNED_64BIT: bigint;
+declare const MAX_SIGNED_64BIT: bigint;
+declare const MAX_UNSIGNED_64BIT: bigint;
+declare const splitToLowHigh64bit: (value: number | bigint) => {
+    low: number;
+    high: number;
+};
+declare const readI64: (ptr: any, isSigned?: boolean) => bigint;
+declare const writeI64: (ptr: number, value: number | bigint, signed?: boolean) => void;
+
+declare const unrefObject: (ptr: number) => void;
+declare const assertSuccess: (result: number, lastError: string) => void;
+declare const readBufferData: (bufferPtr: number) => Uint8Array;
+
+declare const readCredential: (credentialPtr: number) => Credential;
+declare const writeCredential: (credential: Credential) => number;
+
+declare const blake2bHashFromBytes: (data: Uint8Array) => number;
+declare const blake2bHashFromHex: (hex: string) => number;
+declare const readBlake2bHashData: (bufferPtr: number) => Uint8Array;
+
+export { Address, AddressType, Base58, BaseAddress, Bech32, type Bech32DecodeResult, Bip32PrivateKey, Bip32PublicKey, Blake2b, ByronAddress, ByronAddressType, CborMajorType, CborReader, CborReaderState, CborSimpleValue, CborTag, CborWriter, Crc32, type Credential, CredentialType, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, Emip003, EnterpriseAddress, MAX_SIGNED_64BIT, MAX_UNSIGNED_64BIT, MIN_SIGNED_64BIT, NetworkId, Pbkdf2HmacSha512, PointerAddress, RewardAddress, type StakePointer, assertSuccess, blake2bHashFromBytes, blake2bHashFromHex, finalizationRegistry, getErrorString, getLibCardanoCVersion, getModule, hexToUint8Array, isReady, readBlake2bHashData, readBufferData, readCredential, readI64, ready, splitToLowHigh64bit, uint8ArrayToHex, uint8ArrayToUtf8, unrefObject, utf8ToUint8Array, writeCredential, writeI64, writeStringToMemory };