@leofcoin/chain 1.5.11 → 1.5.13

package/exports/chain.js

@@ -1,7 +1,7 @@
 import { formatBytes, BigNumber, formatUnits, parseUnits } from '@leofcoin/utils';
 import { TransactionMessage, BlockMessage, ContractMessage, BWMessage, BWRequestMessage } from '@leofcoin/messages';
 import addresses, { contractFactory, nativeToken, validators, nameService } from '@leofcoin/addresses';
-import { calculateFee, createContractMessage, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, signTransaction } from '@leofcoin/lib';
+import { calculateFee, createContractMessage, signTransaction, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
 import { randombytes } from '@leofcoin/crypto';
 import EasyWorker from '@vandeurenglenn/easy-worker';
 import { isResolveError, ResolveError } from '@leofcoin/errors';
@@ -83,7 +83,9 @@ class Transaction extends Protocol {
         transactions = await this.promiseTransactions(transactions);
         transactions = transactions.filter(tx => tx.decoded.from === address);
         transactions = await this.promiseTransactionsContent(transactions);
+        // @ts-ignore
         if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== '0x0') {
+            // @ts-ignore
             let block = await peernet.get(this.lastBlock.hash, 'block');
             block = await new BlockMessage(block);
             // for (let tx of block.decoded?.transactions) {
@@ -147,6 +149,9 @@ class Transaction extends Protocol {
             return true;
         return false;
     }
+    async createTransactionMessage(transaction, signature) {
+        return new TransactionMessage({ ...transaction, signature });
+    }
     async createTransaction(transaction) {
         return {
             from: transaction.from,
@@ -239,17 +244,25 @@ class Contract extends Transaction {
      * @param {Array} parameters
      * @returns
      */
-    async deployContract(contract, constructorParameters = []) {
-        const message = await createContractMessage(peernet.selectedAccount, contract, constructorParameters);
+    async deployContract(signer, contract, constructorParameters = []) {
+        const message = await createContractMessage(await signer.address, contract, constructorParameters);
+        return this.deployContractMessage(signer, message);
+    }
+    async deployContractMessage(signer, message) {
         try {
-            await contractStore.put(await message.hash(), message.encoded);
+            await globalThis.contractStore.put(await message.hash(), message.encoded);
         }
         catch (error) {
             throw error;
         }
-        return this.createTransactionFrom(peernet.selectedAccount, addresses.contractFactory, 'registerContract', [await message.hash()]);
-    }
-    async deployContractMessage(message) {
+        let transaction = {
+            from: await signer.address,
+            to: addresses.contractFactory,
+            method: 'registerContract',
+            params: [await message.hash()]
+        };
+        transaction = await signTransaction(await this.createTransaction(transaction), signer);
+        return this.sendTransaction(transaction);
     }
 }
 
@@ -264,8 +277,7 @@ class Machine {
         // @ts-ignore
         return this.#init(blocks);
     }
-    // @ts-ignore
-    #createMessage(sender = globalThis.peernet.selectedAccount) {
+    #createMessage(sender = peernet.selectedAccount) {
         return {
             sender,
             call: this.execute,
@@ -467,7 +479,7 @@ class Machine {
      * @returns Promise
      */
     async deleteAll() {
-        let hashes = await globalThis.contractStore.get();
+        let hashes = await globalThis.contractStore.keys();
         hashes = Object.keys(hashes).map(hash => this.delete(hash));
         return Promise.all(hashes);
     }
@@ -687,6 +699,7 @@ class State extends Contract {
         return new globalThis.peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
     }
     getLatestBlock() {
+        // @ts-ignore
         return this.#getLatestBlock();
     }
     async getAndPutBlock(hash) {
@@ -697,7 +710,7 @@ class State extends Contract {
             const { index } = block.decoded;
             if (this.#blocks[index - 1] && this.#blocks[index - 1].hash !== block.hash)
                 throw `invalid block ${hash} @${index}`;
-            if (!await globalThis.peernet.has(hash, 'block'))
+            if (!await globalThis.peernet.has(hash))
                 await globalThis.peernet.put(hash, block.encoded, 'block');
         }
         return block;
@@ -840,7 +853,7 @@ class State extends Contract {
             if (this.knownBlocks?.length === Number(lastBlock.index) + 1) {
                 let promises = [];
                 promises = await Promise.allSettled(this.knownBlocks.map(async (address) => {
-                    const has = await globalThis.peernet.has(address, 'block');
+                    const has = await globalThis.peernet.has(address);
                     return { has, address };
                 }));
                 promises = promises.filter(({ status, value }) => status === 'fulfilled' && !value.has);
@@ -870,6 +883,7 @@ class State extends Contract {
         let data = await new globalThis.peernet.protos['peernet-request']({ request: 'lastBlock' });
         let node = await globalThis.peernet.prepareMessage(data);
         for (const peer of globalThis.peernet?.connections) {
+            // @ts-ignore
             if (peer.connected && peer.version === this.version) {
                 const task = async () => {
                     try {
@@ -883,6 +897,7 @@ class State extends Contract {
                 promises.push(task());
             }
         }
+        // @ts-ignore
         promises = await this.promiseRequests(promises);
         let latest = { index: 0, hash: '0x0', previousHash: '0x0' };
         promises = promises.sort((a, b) => b.index - a.index);
@@ -927,7 +942,7 @@ class State extends Contract {
                     if (lastTransactions.includes(hash)) {
                         console.log('removing invalid block');
                         await globalThis.blockStore.delete(await (await new BlockMessage(block)).hash());
-                        blocks.splice(block.index - 1);
+                        blocks.splice(block.index);
                         return this.#loadBlocks(blocks);
                     }
                     try {
@@ -953,6 +968,7 @@ class State extends Contract {
                     }
                 }
                 this.#blocks[block.index - 1].loaded = true;
+                // @ts-ignore
                 globalThis.debug(`loaded block: ${block.hash} @${block.index}`);
                 globalThis.pubsub.publish('block-loaded', { ...block });
             }
@@ -1000,7 +1016,7 @@ class State extends Contract {
 }
 
 globalThis.BigNumber = BigNumber;
-const ignorelist = ['BA5XUACBBBAT653LT3GHP2Z5SUHVCA42BP6IBFBJACHOZIHHR4DUPG2XMB', 'BA5XUACK6K5XA5P4BHRZ4SZT6FCLO6GLGCLUAD62WBPVLFK73RHZZUFLEG'];
+const ignorelist = [];
 // check if browser or local
 class Chain extends State {
     #state;
@@ -1074,7 +1090,9 @@ class Chain extends State {
                 message: nameServiceMessage
             }];
         await Promise.all(contracts.map(async ({ address, message }) => {
+            // @ts-ignore
             message = await new ContractMessage(Uint8Array.from(message.split(',').map(string => Number(string))));
+            // @ts-ignore
             await globalThis.contractStore.put(address, message.encoded);
         }));
         console.log('handle native contracts');
@@ -1206,20 +1224,24 @@ class Chain extends State {
     async #addBlock(block) {
         const blockMessage = await new BlockMessage(block);
         await Promise.all(blockMessage.decoded.transactions
-            .map(async (transaction) => globalThis.transactionPoolStore.delete(transaction.hash)));
+            // @ts-ignore
+            .map(async (transaction) => transactionPoolStore.delete(transaction.hash)));
         const hash = await blockMessage.hash();
         await globalThis.blockStore.put(hash, blockMessage.encoded);
-        if (this.lastBlock.index < blockMessage.decoded.index)
+        if (this.lastBlock.index < Number(blockMessage.decoded.index))
             await this.updateState(blockMessage);
         globalThis.debug(`added block: ${hash}`);
         let promises = [];
         let contracts = [];
         for (let transaction of blockMessage.decoded.transactions) {
             // await transactionStore.put(transaction.hash, transaction.encoded)
+            // @ts-ignore
             const index = contracts.indexOf(transaction.to);
+            // @ts-ignore
             if (index === -1)
                 contracts.push(transaction.to);
-            // Todo: go trough all accounts      
+            // Todo: go trough all accounts
+            // @ts-ignore
             promises.push(this.#executeTransaction(transaction));
         }
         try {
@@ -1345,7 +1367,7 @@ class Chain extends State {
                 const peer = peers[validator];
                 if (peer && peer.connected && peer.version === this.version) {
                     let data = await new BWRequestMessage();
-                    const node = await globalThis.peernet.prepareMessage(validator, data.encoded);
+                    const node = await globalThis.peernet.prepareMessage(data.encoded);
                     try {
                         const bw = await peer.request(node.encoded);
                         block.validators.push({
@@ -1450,9 +1472,7 @@ class Chain extends State {
         return {
             sender,
             call: this.call,
-            staticCall: this.staticCall,
-            delegate: this.delegate,
-            staticDelegate: this.staticDelegate
+            staticCall: this.staticCall
         };
     }
     /**
@@ -1482,14 +1502,6 @@ class Chain extends State {
         globalThis.msg = this.#createMessage();
         return this.machine.get(contract, method, parameters);
     }
-    delegate(contract, method, parameters) {
-        globalThis.msg = this.#createMessage();
-        return this.machine.execute(contract, method, parameters);
-    }
-    staticDelegate(contract, method, parameters) {
-        globalThis.msg = this.#createMessage();
-        return this.machine.get(contract, method, parameters);
-    }
     mint(to, amount) {
         return this.call(addresses.nativeToken, 'mint', [to, amount]);
     }

package/exports/contract.d.ts

@@ -0,0 +1,45 @@
+import Transaction from "./transaction.js";
+import type MultiWallet from '@leofcoin/multi-wallet';
+/**
+ * @extends {Transaction}
+ */
+export default class Contract extends Transaction {
+    constructor();
+    init(): Promise<void>;
+    /**
+     *
+     * @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 | 0 | import("@ethersproject/bignumber").BigNumber;
+        wait: Promise<unknown>;
+        message: any;
+    }>;
+    deployContractMessage(signer: any, message: any): Promise<{
+        hash: any;
+        data: any;
+        fee: string | 0 | import("@ethersproject/bignumber").BigNumber;
+        wait: Promise<unknown>;
+        message: any;
+    }>;
+}

package/exports/{types/machine.d.ts → machine.d.ts}

@@ -15,10 +15,10 @@ export default class Machine {
      * @param {Array} parameters
      * @returns Promise<message>
      */
-    execute(contract: any, method: any, parameters: any): Promise<unknown>;
-    get(contract: any, method: any, parameters?: any): Promise<unknown>;
+    execute(contract: any, method: any, parameters: any): Promise<any>;
+    get(contract: any, method: any, parameters?: any): Promise<any>;
     has(address: any): Promise<unknown>;
-    delete(hash: any): Promise<any>;
+    delete(hash: any): Promise<void>;
     /**
      *
      * @returns Promise

package/exports/node.js

@@ -6,6 +6,7 @@ import networks from '@leofcoin/networks';
 class Node {
     #node;
     constructor(config, password) {
+        // @ts-ignore
         return this._init(config, password);
     }
     async _init(config = {

package/exports/{types/state.d.ts → state.d.ts}

@@ -27,8 +27,8 @@ export default class State extends Contract {
     constructor();
     init(): Promise<void>;
     updateState(message: any): Promise<void>;
-    getLatestBlock(): Promise<BlockMessage.decoded>;
-    getAndPutBlock(hash: string): BlockMessage;
+    getLatestBlock(): Promise<BlockMessage['decoded']>;
+    getAndPutBlock(hash: string): Promise<BlockMessage>;
     resolveBlock(hash: any): any;
     resolveBlocks(): Promise<void>;
     restoreChain(): Promise<void>;

package/exports/{types/transaction.d.ts → transaction.d.ts}

@@ -29,6 +29,7 @@ export default class Transaction extends Protocol {
     getNonce(address: any): Promise<number>;
     validateNonce(address: any, nonce: any): Promise<void>;
     isTransactionMessage(message: any): boolean;
+    createTransactionMessage(transaction: any, signature: any): Promise<TransactionMessage>;
     createTransaction(transaction: any): Promise<{
         from: any;
         to: any;
@@ -40,7 +41,7 @@ export default class Transaction extends Protocol {
     sendTransaction(message: any): Promise<{
         hash: any;
         data: any;
-        fee: any;
+        fee: string | 0 | import("@leofcoin/utils").BigNumber;
         wait: Promise<unknown>;
         message: any;
     }>;

package/exports/{types/typer.d.ts → typer.d.ts}

@@ -1,5 +1,5 @@
 declare namespace _default {
-    export function isType(type: any, value: any): any;
+    export function isType(type: any, value: any): boolean;
     export { isAddress };
 }
 export default _default;