@leofcoin/chain 1.9.6 → 1.9.9

package/exports/constants-C83ZCYKa.js

@@ -0,0 +1,12 @@
+import networks from '@leofcoin/networks';
+
+const PROTOCOL_VERSION = "0.1.1";
+const REACHED_ONE_ZERO_ZERO = false;
+const DEFAULT_NODE_OPTIONS = {
+  network: "leofcoin:peach",
+  networkVersion: "peach",
+  version: PROTOCOL_VERSION,
+  stars: networks.leofcoin.peach.stars
+};
+
+export { DEFAULT_NODE_OPTIONS as D, PROTOCOL_VERSION as P, REACHED_ONE_ZERO_ZERO as R };

package/exports/node.js

@@ -1,32 +1,27 @@
 import Peernet from '@leofcoin/peernet';
 import nodeConfig from '@leofcoin/lib/node-config';
-import { D as DEFAULT_NODE_OPTIONS } from './constants-eo0U5-D_.js';
+import { D as DEFAULT_NODE_OPTIONS } from './constants-C83ZCYKa.js';
 import '@leofcoin/networks';
 
-// import config from './config/config'
 class Node {
-    #node;
-    constructor(config, password) {
-        this.ready = this._init(config, password);
-    }
-    async _init(config = {
-        autoStart: false
-    }, password) {
-        config = { ...DEFAULT_NODE_OPTIONS, ...config };
-        this.#node = globalThis.Peernet
-            ? await new globalThis.Peernet(config, password)
-            : await new Peernet(config, password);
-        await nodeConfig(config);
-        globalThis.pubsub.subscribe('chain:ready', async () => {
-            // when autostart is false the node will only be started after the chain is ready (this is here so we can just use node for communication)
-            if (!this.#node.autoStart) {
-                await this.#node.start();
-                pubsub.publish('node:ready', true);
-            }
-        });
-        return this;
-        // this.config = await config()
-    }
+  #node;
+  constructor(config, password) {
+    this.ready = this._init(config, password);
+  }
+  async _init(config = {
+    autoStart: false
+  }, password) {
+    config = { ...DEFAULT_NODE_OPTIONS, ...config };
+    this.#node = globalThis.Peernet ? await new globalThis.Peernet(config, password) : await new Peernet(config, password);
+    await nodeConfig(config);
+    globalThis.pubsub.subscribe("chain:ready", async () => {
+      if (!this.#node.autoStart) {
+        await this.#node.start();
+        pubsub.publish("node:ready", true);
+      }
+    });
+    return this;
+  }
 }
 
 export { Node as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.9.6",
+  "version": "1.9.9",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {
@@ -56,6 +56,7 @@
     "@types/semver": "^7.7.1",
     "@vandeurenglenn/debug": "^1.4.0",
     "rollup": "^4.60.1",
+    "rollup-plugin-esbuild": "^6.2.1",
     "rollup-plugin-modify": "^3.0.0",
     "tape": "^5.9.0",
     "tslib": "^2.8.1"

package/exports/chain.d.ts

@@ -1,73 +0,0 @@
-import { VersionControl } from './version-control.js';
-export default class Chain extends VersionControl {
-    #private;
-    id: any;
-    utils: {};
-    readyResolve: (value: boolean | PromiseLike<boolean>) => void;
-    ready: Promise<boolean>;
-    constructor(config: any);
-    get nativeToken(): string;
-    get validators(): any[];
-    hasTransactionToHandle(): Promise<boolean>;
-    getPeerTransactionPool(peer: any): Promise<any[]>;
-    participate(address: any): Promise<void>;
-    /**
-     * every tx done is trough contracts so no need for amount
-     * data is undefined when nothing is returned
-     * error is thrown on error so undefined data doesn't mean there is an error...
-     **/
-    sendTransaction(transaction: any): Promise<{
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    }>;
-    addContract(transaction: any, contractMessage: any): Promise<{
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    }>;
-    /**
-     *
-     * @param {Address} sender
-     * @param {Address} contract
-     * @param {String} method
-     * @param {Array} parameters
-     * @returns
-     */
-    internalCall(sender: Address, contract: Address, method: string, parameters?: any[]): Promise<any>;
-    /**
-     *
-     * @param {Address} contract
-     * @param {String} method
-     * @param {Array} parameters
-     * @returns
-     */
-    call(contract: Address, method: string, parameters?: any[]): Promise<any>;
-    staticCall(contract: Address, method: string, parameters?: any[]): Promise<any>;
-    mint(to: Address, amount: bigint): Promise<any>;
-    transfer(from: Address, to: Address, amount: bigint): Promise<any>;
-    balanceOf(address: Address): Promise<bigint>;
-    get balance(): Promise<bigint>;
-    get balances(): Promise<{
-        [index: string]: bigint;
-    }>;
-    get contracts(): Promise<any>;
-    deleteAll(): Promise<any[]>;
-    /**
-     * lookup an address for a registered name using the builtin nameService
-     * @check nameService
-     *
-     * @param {String} - contractName
-     * @returns {String} - address
-     *
-     * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
-     */
-    lookup(name: any): Promise<{
-        owner: any;
-        address: any;
-    }>;
-}

package/exports/config/config.d.ts

@@ -1 +0,0 @@
-export {};

package/exports/config/main.d.ts

@@ -1,5 +0,0 @@
-declare namespace _default {
-    let datadir: string;
-    let configPath: string;
-}
-export default _default;

package/exports/config/protocol.d.ts

@@ -1,6 +0,0 @@
-declare namespace _default {
-    namespace block {
-        let size: number;
-    }
-}
-export default _default;

package/exports/connection-monitor.d.ts

@@ -1,14 +0,0 @@
-import Peer from '@netpeer/swarm/peer';
-/**
- * Connection Monitor - Monitors peer connections and handles reconnection logic
- */
-export default class ConnectionMonitor {
-    #private;
-    get isMonitoring(): boolean;
-    get connectedPeers(): Peer[];
-    get compatiblePeers(): Peer[];
-    get disconnectedPeers(): Peer[];
-    start(version: any): void;
-    stop(): void;
-    waitForPeers(timeoutMs?: number): Promise<boolean>;
-}

package/exports/consensus/consensus.d.ts

@@ -1 +0,0 @@
-export {};

package/exports/consensus/helpers/sort-transactions.d.ts

@@ -1 +0,0 @@
-export {};

package/exports/constants-eo0U5-D_.js

@@ -1,12 +0,0 @@
-import networks from '@leofcoin/networks';
-
-const PROTOCOL_VERSION = '0.1.1';
-const REACHED_ONE_ZERO_ZERO = false; // set to true when protocol reaches v1.0.0
-const DEFAULT_NODE_OPTIONS = {
-    network: 'leofcoin:peach',
-    networkVersion: 'peach',
-    version: PROTOCOL_VERSION,
-    stars: networks.leofcoin.peach.stars
-};
-
-export { DEFAULT_NODE_OPTIONS as D, PROTOCOL_VERSION as P, REACHED_ONE_ZERO_ZERO as R };

package/exports/constants.d.ts

@@ -1,15 +0,0 @@
-export declare const PROTOCOL_VERSION = "0.1.1";
-export declare const MACHINE_STATE_VERSION = "1";
-export declare const REACHED_ONE_ZERO_ZERO = false;
-export type NodeOptions = {
-    network?: string;
-    networkVersion?: string;
-    version?: string;
-    stars?: string[];
-};
-export declare const DEFAULT_NODE_OPTIONS: {
-    network: string;
-    networkVersion: string;
-    version: string;
-    stars: string[];
-};

package/exports/contract-registry.d.ts

@@ -1,106 +0,0 @@
-import { ContractMessage } from '@leofcoin/messages';
-/**
- * Registry for managing base contracts and contract inheritance
- */
-export declare class ContractRegistry {
-    private baseContracts;
-    private contractNames;
-    private contractDependencies;
-    /**
-     * Register a base contract that can be reused
-     * Uses the contract code hash as the identifier and registers the name in nameService
-     * @param name The name to register in nameService
-     * @param message The contract message
-     * @returns The contract hash
-     */
-    registerBaseContract(name: string, message: ContractMessage): Promise<string>;
-    /**
-     * Register a name for a contract hash in the nameService
-     * @param name The name to register
-     * @param hash The contract hash
-     * @param chain The chain instance (for making transactions)
-     * @param signer The wallet to sign the transaction
-     */
-    registerNameInNameService(name: string, hash: string, chain: any, signer: any): Promise<void>;
-    /**
-     * Get a base contract by name
-     * First checks local registry, then queries nameService if available
-     * @param name The name of the base contract
-     * @returns The contract message or undefined
-     */
-    getBaseContract(name: string): ContractMessage | undefined;
-    /**
-     * Get a base contract by hash
-     * @param hash The hash of the contract
-     * @returns The contract message or undefined
-     */
-    getBaseContractByHash(hash: string): ContractMessage | undefined;
-    /**
-     * Resolve a name to a hash (first local, then nameService)
-     * @param name The contract name
-     * @returns The contract hash or undefined
-     */
-    resolveNameToHash(name: string): string | undefined;
-    /**
-     * Register contract dependencies (inheritance chain)
-     * @param contractHash The hash of the contract
-     * @param dependencies Array of base contract hashes this contract depends on
-     */
-    registerDependencies(contractHash: string, dependencies: string[]): void;
-    /**
-     * Get all dependencies for a contract
-     * @param contractHash The hash of the contract
-     * @returns Array of dependency hashes
-     */
-    getDependencies(contractHash: string): string[];
-    /**
-     * Check if all dependencies for a contract are available
-     * @param contractHash The hash of the contract
-     * @returns true if all dependencies are available
-     */
-    areDependenciesAvailable(contractHash: string): Promise<boolean>;
-    /**
-     * Get all registered contract hashes
-     * @returns Array of contract hashes
-     */
-    getBaseContractHashes(): string[];
-    /**
-     * Get hash for a registered name
-     * @param name The contract name
-     * @returns The hash or undefined
-     */
-    getHashForName(name: string): string | undefined;
-    /**
-     * Analyze contract code and extract inheritance information
-     * @param contractCode The contract code to analyze
-     * @returns Inheritance information
-     */
-    analyzeContract(contractCode: string): {
-        className: string | null;
-        baseClass: string | null;
-        hasInheritance: boolean;
-    };
-    /**
-     * Build a complete contract by combining base contracts
-     * @param contractCode The derived contract code
-     * @param baseContractIdentifiers Names or hashes of base contracts to include
-     * @returns Combined contract code
-     */
-    buildContract(contractCode: string, baseContractIdentifiers?: string[]): Promise<string>;
-    /**
-     * Clear all registered contracts
-     */
-    clear(): void;
-    /**
-     * Get all registered base contract names
-     * @returns Array of base contract names
-     */
-    getBaseContractNames(): string[];
-    /**
-     * Get name for a hash if registered
-     * @param hash The contract hash
-     * @returns The name or undefined
-     */
-    getNameForHash(hash: string): string | undefined;
-}
-export declare const contractRegistry: ContractRegistry;

package/exports/contract-utils.d.ts

@@ -1,49 +0,0 @@
-/**
- * Create a hash from contract code using ContractMessage's hash method
- * For base contracts, omit constructorParameters to hash only the code
- * @param creator The creator address
- * @param contractCode The contract code to hash
- * @param constructorParameters Constructor parameters (omit for base contracts)
- * @returns Promise<string> The hash of the contract
- */
-export declare const hashContractCode: (creator: string, contractCode: string, constructorParameters?: any[]) => Promise<string>;
-/**
- * Check if a class is derived from another class
- * @param derivedClass The class to check
- * @param baseClass The potential base class
- * @returns true if derivedClass extends baseClass
- */
-export declare const isDerivedFrom: (derivedClass: any, baseClass: any) => boolean;
-/**
- * Check if a class instance is derived from another class
- * @param instance The instance to check
- * @param baseClass The potential base class
- * @returns true if instance's class extends baseClass
- */
-export declare const isInstanceOf: (instance: any, baseClass: any) => boolean;
-/**
- * Get the inheritance chain of a class
- * @param classConstructor The class to get the inheritance chain for
- * @returns Array of class names in the inheritance chain
- */
-export declare const getInheritanceChain: (classConstructor: any) => string[];
-/**
- * Extract base contract code from a contract
- * Useful for separating reusable code into base contracts
- * @param contractCode The contract code to analyze
- * @returns Object with base contract and derived contract code
- */
-export declare const extractBaseContract: (contractCode: string) => {
-    baseCode: string;
-    derivedCode: string;
-};
-/**
- * Parse contract inheritance information from contract code
- * @param contractCode The contract code to parse
- * @returns Information about the contract's inheritance
- */
-export declare const parseContractInheritance: (contractCode: string) => {
-    className: string | null;
-    baseClass: string | null;
-    hasInheritance: boolean;
-};

package/exports/contract.d.ts

@@ -1,90 +0,0 @@
-import Transaction from './transaction.js';
-import type MultiWallet from '@leofcoin/multi-wallet';
-/**
- * @extends {Transaction}
- */
-export default class Contract extends Transaction {
-    constructor(config: any);
-    /**
-     *
-     * @param {Address} creator
-     * @param {String} contract
-     * @param {Array} constructorParameters
-     * @returns lib.createContractMessage
-     */
-    createContractMessage(creator: any, contract: any, constructorParameters?: any[]): Promise<import("@leofcoin/messages").ContractMessage>;
-    /**
-     *
-     * @param {Address} creator
-     * @param {String} contract
-     * @param {Array} constructorParameters
-     * @returns {Address}
-     */
-    createContractAddress(creator: any, contract: any, constructorParameters?: any[]): Promise<any>;
-    /**
-     *
-     * @param {String} contract
-     * @param {Array} parameters
-     * @returns
-     */
-    deployContract(signer: MultiWallet, contract: any, constructorParameters?: any[]): Promise<{
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    }>;
-    /**
-     * Register a base contract for reuse by other contracts
-     * The contract is stored by its hash, enabling inheritance and code reuse
-     * @param {String} name The name to register for this contract
-     * @param {String} contract The contract code
-     * @param {Array} constructorParameters Constructor parameters
-     * @returns {Promise<string>} The contract hash
-     */
-    registerBaseContract(name: string, contract: string, constructorParameters?: any[]): Promise<string>;
-    /**
-     * Deploy a contract with optional base contracts for inheritance
-     * @param {MultiWallet} signer The wallet to sign with
-     * @param {String} contract The contract code
-     * @param {Array} constructorParameters Constructor parameters
-     * @param {Array<string>} baseContracts Optional array of base contract names or hashes
-     * @returns Transaction result
-     */
-    deployDerivedContract(signer: MultiWallet, contract: string, baseContractIdentifier?: string, constructorParameters?: any[]): Promise<{
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    }>;
-    deployContractMessage(signer: any, message: any): Promise<{
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    }>;
-    /**
-     * Check if a class is derived from another class
-     * @param derivedClass The class to check
-     * @param baseClass The potential base class
-     * @returns true if derivedClass extends baseClass
-     */
-    isDerivedFrom(derivedClass: any, baseClass: any): boolean;
-    /**
-     * Parse contract code to extract inheritance information
-     * @param contractCode The contract code to parse
-     * @returns Inheritance information
-     */
-    parseContractInheritance(contractCode: string): {
-        className: string | null;
-        baseClass: string | null;
-        hasInheritance: boolean;
-    };
-    /**
-     * Get the contract registry instance
-     * @returns {ContractRegistry} The contract registry
-     */
-    getRegistry(): import("./contract-registry.js").ContractRegistry;
-}

package/exports/examples/contract-inheritance-example.d.ts

@@ -1,58 +0,0 @@
-/**
- * Example: Using Contract Inheritance and Base Contracts
- *
- * This example demonstrates how to:
- * 1. Check if a class is derived from another class
- * 2. Register reusable base contracts
- * 3. Deploy derived contracts that extend base contracts
- */
-import Contract from '../contract.js';
-import type MultiWallet from '@leofcoin/multi-wallet';
-/**
- * Example usage of the contract system
- */
-export declare function exampleContractDeployment(contractInstance: Contract, signer: MultiWallet): Promise<{
-    baseHash: string;
-    deployResult: {
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    };
-    altDeployResult: {
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    };
-}>;
-/**
- * Example: Creating a modular contract system
- */
-export declare function exampleModularContracts(contractInstance: Contract, signer: MultiWallet): Promise<{
-    hash: any;
-    data: any;
-    fee: string | bigint | 0;
-    wait: Promise<unknown>;
-    message: any;
-}>;
-/**
- * Example: Best practices for contract organization
- */
-export declare const contractBestPractices: {
-    baseContracts: string[];
-    derivedContracts: string[];
-    benefits: string[];
-};
-declare const _default: {
-    exampleContractDeployment: typeof exampleContractDeployment;
-    exampleModularContracts: typeof exampleModularContracts;
-    contractBestPractices: {
-        baseContracts: string[];
-        derivedContracts: string[];
-        benefits: string[];
-    };
-};
-export default _default;

package/exports/examples/hash-based-contracts.d.ts

@@ -1,82 +0,0 @@
-/**
- * Example: Hash-Based Contract Registry with NameService Integration
- *
- * This example demonstrates:
- * 1. Hashing contract code for content-addressed storage
- * 2. Registering contracts by hash with name mappings
- * 3. Using nameService for on-chain name resolution
- * 4. Deploying contracts by name or hash
- */
-import Contract from '../contract.js';
-import type MultiWallet from '@leofcoin/multi-wallet';
-export declare function exampleHashBasedRegistration(contract: Contract, signer: MultiWallet): Promise<{
-    codeHash: string;
-    registeredHash: string;
-    result: {
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    };
-}>;
-export declare function exampleNameServiceIntegration(contract: Contract, signer: MultiWallet): Promise<{
-    hash: string;
-}>;
-export declare function exampleContractAliases(contract: Contract): Promise<{
-    hash1: string;
-    hash2: string;
-}>;
-export declare function exampleVersionedContracts(contract: Contract, signer: MultiWallet): Promise<{
-    v1Hash: string;
-    v2Hash: string;
-    result: {
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    };
-}>;
-export declare function exampleDeployByHash(contract: Contract, signer: MultiWallet): Promise<{
-    baseHash: string;
-    result: {
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    };
-}>;
-export declare function exampleVerifyContract(contract: Contract): Promise<{
-    registeredHash: string;
-    computedHash: string;
-}>;
-export declare function exampleContractDiscovery(contract: Contract): Promise<{
-    names: string[];
-    hashes: string[];
-    nameToHash: {};
-    hashToName: {};
-}>;
-export declare function exampleDependencyResolution(contract: Contract, signer: MultiWallet): Promise<{
-    storageHash: string;
-    validationHash: string;
-    result: {
-        hash: any;
-        data: any;
-        fee: string | bigint | 0;
-        wait: Promise<unknown>;
-        message: any;
-    };
-}>;
-declare const _default: {
-    exampleHashBasedRegistration: typeof exampleHashBasedRegistration;
-    exampleNameServiceIntegration: typeof exampleNameServiceIntegration;
-    exampleContractAliases: typeof exampleContractAliases;
-    exampleVersionedContracts: typeof exampleVersionedContracts;
-    exampleDeployByHash: typeof exampleDeployByHash;
-    exampleVerifyContract: typeof exampleVerifyContract;
-    exampleContractDiscovery: typeof exampleContractDiscovery;
-    exampleDependencyResolution: typeof exampleDependencyResolution;
-};
-export default _default;

package/exports/fee/config.d.ts

@@ -1,4 +0,0 @@
-declare namespace _default {
-    let deployment: number;
-}
-export default _default;

package/exports/helpers/contract.d.ts

@@ -1,4 +0,0 @@
-export default class Contract {
-    constructor(address: any, ABI: any, provider: any, config: any);
-    proxy(): this;
-}

package/exports/jobs/jobber.d.ts

@@ -1,7 +0,0 @@
-export default class Jobber {
-    timeout: EpochTimeStamp;
-    busy: boolean;
-    destroy: Function;
-    constructor(timeout: any);
-    add(fn: any): Promise<unknown>;
-}

package/exports/machine-state.d.ts

@@ -1,6 +0,0 @@
-export default class MachineState {
-    constructor();
-    put(key: any, value: any, isCompressed?: boolean): Promise<void>;
-    get(key: any, isCompressed?: boolean): Promise<any>;
-    updateState(block: any): void;
-}