@leofcoin/chain 1.8.4 → 1.8.6

package/exports/contract-registry.d.ts

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,49 @@
+/**
+ * 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

@@ -34,6 +34,30 @@ export default class Contract extends Transaction {
         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;
@@ -41,4 +65,26 @@ export default class Contract extends Transaction {
         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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,82 @@
+/**
+ * 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/flags.d.ts

@@ -1,2 +1,2 @@
 export declare const reachedOneZeroZero = false;
-export declare const currentVersion = "0.1.0";
+export declare const currentVersion = "0.1.1";

package/exports/machine.d.ts

@@ -22,7 +22,10 @@ export default class Machine {
         };
     };
     wantList: string[];
-    constructor(blocks: any);
+    readyResolve: (value: Machine | PromiseLike<Machine>) => void;
+    ready: Promise<Machine>;
+    constructor(blocks?: any[]);
+    init(blocks: any): Promise<Machine>;
     updateState(): Promise<void>;
     /**
      *

package/exports/node.d.ts

@@ -1,5 +1,6 @@
 export default class Node {
     #private;
+    ready: Promise<this>;
     constructor(config: any, password: any);
     _init(config: {
         autoStart: boolean;

package/exports/node.js

@@ -13,8 +13,7 @@ const DEFAULT_NODE_OPTIONS = {
 class Node {
     #node;
     constructor(config, password) {
-        // @ts-ignore
-        return this._init(config, password);
+        this.ready = this._init(config, password);
     }
     async _init(config = {
         autoStart: false

package/exports/protocol.d.ts

@@ -1,6 +1,6 @@
 import type { ChainConfig } from './types.js';
 export declare const limit = 1800;
-export declare const transactionLimit = 1000;
+export declare const transactionLimit = 2500;
 export declare const requestTimeout = 30000;
 export declare const syncTimeout = 30000;
 export declare class Protocol {