@leofcoin/chain 1.4.36 → 1.4.38

package/exports/chain.js

@@ -448,11 +448,16 @@ class Contract extends Transaction {
         }
         return this.createTransactionFrom(peernet.selectedAccount, addresses.contractFactory, 'registerContract', [await message.hash()]);
     }
+    async deployContractMessage(message) {
+    }
 }
 
 globalThis.BigNumber = BigNumber;
 // check if browser or local
 class Chain extends Contract {
+    #state;
+    id;
+    utils;
     /** {Address[]} */
     #validators = [];
     /** {Block[]} */
@@ -534,7 +539,7 @@ class Chain extends Contract {
         return [...this.#blocks];
     }
     async hasTransactionToHandle() {
-        const size = await transactionPoolStore.size();
+        const size = await globalThis.transactionPoolStore.size();
         if (size > 0)
             return true;
         return false;
@@ -544,7 +549,7 @@ class Chain extends Contract {
         console.log('epoch');
         const validators = await this.staticCall(addresses.validators, 'validators');
         console.log({ validators });
-        if (!validators[globalThis.peernet.selectedAccount]?.active)
+        if (!validators[globalThis.globalThis.peernet.selectedAccount]?.active)
             return;
         const start = Date.now();
         try {
@@ -577,7 +582,7 @@ class Chain extends Contract {
         await Promise.all(contracts.map(async ({ address, message }) => {
             // console.log({message});
             message = await new ContractMessage(Uint8Array.from(message.split(',').map(string => Number(string))));
-            await contractStore.put(address, message.encoded);
+            await globalThis.contractStore.put(address, message.encoded);
         }));
         console.log('handle native contracts');
         // handle native contracts
@@ -586,14 +591,14 @@ class Chain extends Contract {
         return new Promise(async (resolve, reject) => {
             const timeout = setTimeout(() => {
                 resolve([{ index: 0, hash: '0x0' }]);
-                debug('sync timed out');
+                globalThis.debug('sync timed out');
             }, 10_000);
             promises = await Promise.allSettled(promises);
             promises = promises.filter(({ status }) => status === 'fulfilled');
             clearTimeout(timeout);
             if (promises.length > 0) {
                 promises = promises.map(async ({ value }) => {
-                    const node = await new peernet.protos['peernet-response'](value.result);
+                    const node = await new globalThis.peernet.protos['peernet-response'](value.result);
                     return { value: node.decoded.response, peer: value.peer };
                 });
                 promises = await Promise.all(promises);
@@ -609,10 +614,10 @@ class Chain extends Contract {
     }
     async #getLatestBlock() {
         let promises = [];
-        let data = await new peernet.protos['peernet-request']({ request: 'lastBlock' });
-        let node = await peernet.prepareMessage(data);
-        for (const peer of peernet?.connections) {
-            if (peer.connected && peer.readyState === 'open' && peer.peerId !== this.id) {
+        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) {
+            if (peer.connected) {
                 promises.push(async () => {
                     try {
                         const result = await peer.request(node.encoded);
@@ -623,7 +628,11 @@ class Chain extends Contract {
                     }
                 });
             }
-            else if (!peer.connected || peer.readyState !== 'open') ;
+            else if (!peer.connected) {
+                globalThis.peernet.removePeer(peer);
+                // todo: remove peer
+                // reinitiate channel?
+            }
         }
         promises = await this.promiseRequests(promises);
         let latest = { index: 0, hash: '0x0', previousHash: '0x0' };
@@ -631,18 +640,18 @@ class Chain extends Contract {
         if (promises.length > 0)
             latest = promises[0].value;
         if (latest.hash && latest.hash !== '0x0') {
-            let message = await peernet.get(latest.hash, 'block');
+            let message = await globalThis.peernet.get(latest.hash, 'block');
             message = await new BlockMessage(message);
             const hash = await message.hash();
             if (hash !== latest.hash)
                 throw new Error('invalid block @getLatestBlock');
-            let data = await new peernet.protos['peernet-request']({ request: 'knownBlocks' });
-            let node = await peernet.prepareMessage(data);
+            let data = await new globalThis.peernet.protos['peernet-request']({ request: 'knownBlocks' });
+            let node = await globalThis.peernet.prepareMessage(data);
             const peer = promises[0].peer;
             latest = { ...message.decoded, hash };
             if (peer.connected && peer.readyState === 'open' && peer.peerId !== this.id) {
                 let message = await peer.request(node);
-                message = await new peernet.protos['peernet-response'](message);
+                message = await new globalThis.peernet.protos['peernet-response'](message);
                 this.#knownBlocks = message.decoded.response;
             }
         }
@@ -652,33 +661,37 @@ class Chain extends Contract {
         // this.node = await new Node()
         this.#participants = [];
         this.#participating = false;
-        const initialized = await contractStore.has(addresses.contractFactory);
+        const initialized = await globalThis.contractStore.has(addresses.contractFactory);
         if (!initialized)
             await this.#setup();
         this.utils = { BigNumber, formatUnits, parseUnits };
-        this.state = new State();
-        await peernet.addRequestHandler('bw-request-message', () => {
-            return new BWMessage(peernet.client.bw) || { up: 0, down: 0 };
+        this.#state = new State();
+        await globalThis.peernet.addRequestHandler('bw-request-message', () => {
+            return new BWMessage(globalThis.peernet.client.bw) || { up: 0, down: 0 };
         });
-        await peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
-        await peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.bind(this));
-        peernet.subscribe('add-block', this.#addBlock.bind(this));
-        peernet.subscribe('add-transaction', this.#addTransaction.bind(this));
-        peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this));
-        pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
+        // await globalThis.peernet.addRequestHandler('peerId', () => {
+        //   let node = 
+        //   globalThis.peernet.protos['peernet-response']({response: node.encoded})
+        // })
+        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
+        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.bind(this));
+        globalThis.peernet.subscribe('add-block', this.#addBlock.bind(this));
+        globalThis.peernet.subscribe('add-transaction', this.#addTransaction.bind(this));
+        globalThis.peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this));
+        globalThis.pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
         // todo some functions rely on state
         try {
             let localBlock;
             try {
-                localBlock = await chainStore.get('lastBlock');
+                localBlock = await globalThis.chainStore.get('lastBlock');
             }
             catch {
-                await chainStore.put('lastBlock', '0x0');
-                localBlock = await chainStore.get('lastBlock');
+                await globalThis.chainStore.put('lastBlock', '0x0');
+                localBlock = await globalThis.chainStore.get('lastBlock');
             }
             localBlock = new TextDecoder().decode(localBlock);
             if (localBlock && localBlock !== '0x0') {
-                localBlock = await peernet.get(localBlock, 'block');
+                localBlock = await globalThis.peernet.get(localBlock, 'block');
                 localBlock = await new BlockMessage(localBlock);
                 this.#lastBlock = { ...localBlock.decoded, hash: await localBlock.hash() };
             }
@@ -696,15 +709,22 @@ class Chain extends Contract {
         await this.resolveBlocks();
         this.#machine = await new Machine(this.#blocks);
         await this.#loadBlocks(this.#blocks);
-        globalThis.pubsub.publish('chain:ready', true);
+        globalThis.globalThis.pubsub.publish('chain:ready', true);
         return this;
     }
     async #validatorTimeout(validatorInfo) {
         setTimeout(() => {
-            this.#jail.splice(this.jail.indexOf(validatorInfo.address), 1);
+            this.#jail.splice(this.#jail.indexOf(validatorInfo.address), 1);
         }, validatorInfo.timeout);
         this.#jail.push(validatorInfo.address);
     }
+    async triggerSync() {
+        if (this.#chainSyncing)
+            return 'already syncing';
+        const latest = await this.#getLatestBlock();
+        await this.#syncChain(latest);
+        return 'synced';
+    }
     async #syncChain(lastBlock) {
         if (this.#chainSyncing || !lastBlock || !lastBlock.hash || !lastBlock.hash)
             return;
@@ -712,7 +732,7 @@ class Chain extends Contract {
         if (this.#knownBlocks?.length === Number(lastBlock.index) + 1) {
             let promises = [];
             promises = await Promise.allSettled(this.#knownBlocks.map(async (address) => {
-                const has = await peernet.has(address, 'block');
+                const has = await globalThis.peernet.has(address, 'block');
                 return { has, address };
             }));
             promises = promises.filter(({ status, value }) => status === 'fulfilled' && !value.has);
@@ -724,53 +744,58 @@ class Chain extends Contract {
             const index = lastBlock.index;
             await this.resolveBlock(lastBlock.hash);
             let blocksSynced = localIndex > 0 ? (localIndex > index ? localIndex - index : index - localIndex) : index;
-            debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`);
+            globalThis.debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`);
             const start = (this.#blocks.length - blocksSynced) - 1;
-            await this.#loadBlocks(this.blocks.slice(start));
+            if (this.#machine)
+                await this.#loadBlocks(this.blocks.slice(start));
             await this.#updateState(new BlockMessage(this.#blocks[this.#blocks.length - 1]));
         }
         this.#chainSyncing = false;
     }
     async #peerConnected(peer) {
-        let node = await new peernet.protos['peernet-request']({ request: 'lastBlock' });
-        node = await peernet.prepareMessage(node);
+        let node = await new globalThis.peernet.protos['peernet-request']({ request: 'lastBlock' });
+        node = await globalThis.peernet.prepareMessage(node);
         let response = await peer.request(node.encoded);
-        response = await new globalThis.peernet.protos['peernet-response'](response);
+        response = await new globalThis.globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)));
         let lastBlock = response.decoded.response;
         // try catch known blocks
-        node = await new peernet.protos['peernet-request']({ request: 'knownBlocks' });
-        node = await peernet.prepareMessage(node);
+        node = await new globalThis.peernet.protos['peernet-request']({ request: 'knownBlocks' });
+        node = await globalThis.peernet.prepareMessage(node);
         response = await peer.request(node.encoded);
-        response = await new globalThis.peernet.protos['peernet-response'](response);
+        response = await new globalThis.globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)));
         this.#knownBlocks = response.decoded.response;
         this.#syncChain(lastBlock);
     }
     #epochTimeout;
     async #lastBlockHandler() {
-        return new peernet.protos['peernet-response']({ response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index } });
+        return new globalThis.peernet.protos['peernet-response']({ response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index } });
     }
     async #knownBlocksHandler() {
-        return new peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
+        return new globalThis.peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
     }
     async getAndPutBlock(hash) {
-        let block = await peernet.get(hash, 'block');
+        let block = await globalThis.peernet.get(hash, 'block');
         block = await new BlockMessage(block);
         const { index } = block.decoded;
         if (this.#blocks[index] && this.#blocks[index].hash !== block.hash)
             throw `invalid block ${hash} @${index}`;
-        if (!await peernet.has(hash, 'block'))
-            await peernet.put(hash, block.encoded, 'block');
+        if (!await globalThis.peernet.has(hash, 'block'))
+            await globalThis.peernet.put(hash, block.encoded, 'block');
         return block;
     }
     async resolveBlock(hash) {
         if (!hash)
             throw new Error(`expected hash, got: ${hash}`);
+        if (hash === '0x0')
+            return;
         const index = this.#blockHashMap.get(hash);
         if (this.#blocks[index]) {
             if (this.#blocks[index].previousHash !== '0x0') {
-                return this.resolveBlock(this.#blocks[index]);
+                return this.resolveBlock(this.#blocks[index].previousHash);
+            }
+            else {
+                return;
             }
-            return;
         }
         try {
             const block = await this.getAndPutBlock(hash);
@@ -790,14 +815,14 @@ class Chain extends Contract {
     }
     async resolveBlocks() {
         try {
-            const localBlock = await chainStore.get('lastBlock');
+            const localBlock = await globalThis.chainStore.get('lastBlock');
             const hash = new TextDecoder().decode(localBlock);
             if (hash && hash !== '0x0')
                 await this.resolveBlock(hash);
             this.#lastBlock = this.#blocks[this.#blocks.length - 1];
         }
         catch {
-            await chainStore.put('lastBlock', new TextEncoder().encode('0x0'));
+            await globalThis.chainStore.put('lastBlock', new TextEncoder().encode('0x0'));
             return this.resolveBlocks();
             // console.log(e);
         }
@@ -828,7 +853,7 @@ class Chain extends Contract {
                     }
                 }
                 this.#blocks[block.index].loaded = true;
-                debug(`loaded block: ${block.hash} @${block.index}`);
+                globalThis.debug(`loaded block: ${block.hash} @${block.index}`);
             }
         }
     }
@@ -836,25 +861,24 @@ class Chain extends Contract {
         try {
             let result = await this.#machine.execute(to, method, params, from, nonce);
             // if (!result) result = this.#machine.state
-            pubsub.publish(`transaction.completed.${hash}`, { status: 'fulfilled', hash });
+            globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: 'fulfilled', hash });
             return result || 'no state change';
         }
         catch (error) {
             console.log(error);
-            pubsub.publish(`transaction.completed.${hash}`, { status: 'fail', hash, error: error });
+            globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: 'fail', hash, error: error });
             throw error;
         }
     }
     async #addBlock(block) {
-        // console.log(block);
         const blockMessage = await new BlockMessage(block);
         await Promise.all(blockMessage.decoded.transactions
-            .map(async (transaction) => transactionPoolStore.delete(transaction.hash)));
+            .map(async (transaction) => globalThis.transactionPoolStore.delete(transaction.hash)));
         const hash = await blockMessage.hash();
-        await blockStore.put(hash, blockMessage.encoded);
+        await globalThis.blockStore.put(hash, blockMessage.encoded);
         if (this.lastBlock.index < blockMessage.decoded.index)
             await this.#updateState(blockMessage);
-        debug(`added block: ${hash}`);
+        globalThis.debug(`added block: ${hash}`);
         let promises = [];
         let contracts = [];
         for (let transaction of blockMessage.decoded.transactions) {
@@ -868,10 +892,10 @@ class Chain extends Contract {
         try {
             promises = await Promise.allSettled(promises);
             for (let transaction of blockMessage.decoded.transactions) {
-                pubsub.publish('transaction-processed', transaction);
-                if (transaction.to === peernet.selectedAccount)
-                    pubsub.publish('account-transaction-processed', transaction);
-                await accountsStore.put(transaction.from, String(transaction.nonce));
+                globalThis.pubsub.publish('transaction-processed', transaction);
+                if (transaction.to === globalThis.peernet.selectedAccount)
+                    globalThis.pubsub.publish('account-transaction-processed', transaction);
+                await globalThis.accountsStore.put(transaction.from, String(transaction.nonce));
             }
             // todo finish state
             // for (const contract of contracts) {
@@ -879,7 +903,7 @@ class Chain extends Contract {
             //   // await stateStore.put(contract, state)
             //   console.log(state);
             // }
-            pubsub.publish('block-processed', blockMessage.decoded);
+            globalThis.pubsub.publish('block-processed', blockMessage.decoded);
         }
         catch (error) {
             console.log({ e: error });
@@ -889,7 +913,7 @@ class Chain extends Contract {
         const hash = await message.hash();
         this.#lastBlock = { hash, ...message.decoded };
         // await this.state.updateState(message)
-        await chainStore.put('lastBlock', hash);
+        await globalThis.chainStore.put('lastBlock', hash);
     }
     async participate(address) {
         // TODO: validate participant
@@ -908,7 +932,7 @@ class Chain extends Contract {
                 nonce: (await this.getNonce(address)) + 1,
                 timestamp: Date.now()
             };
-            const transaction = await signTransaction(rawTransaction, peernet.identity);
+            const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity);
             await this.sendTransaction(transaction);
         }
         if (await this.hasTransactionToHandle() && !this.#runningEpoch)
@@ -917,15 +941,19 @@ class Chain extends Contract {
     // todo filter tx that need to wait on prev nonce
     async #createBlock(limit = 1800) {
         // vote for transactions
-        if (await transactionPoolStore.size() === 0)
+        if (await globalThis.transactionPoolStore.size() === 0)
             return;
-        let transactions = await transactionPoolStore.values(this.transactionLimit);
+        let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit);
         if (Object.keys(transactions)?.length === 0)
             return;
         let block = {
             transactions: [],
             validators: [],
-            fees: BigNumber.from(0)
+            fees: BigNumber.from(0),
+            timestamp: Date.now(),
+            previousHash: '',
+            reward: parseUnits('150'),
+            index: 0
         };
         // exclude failing tx
         transactions = await this.promiseTransactions(transactions);
@@ -935,11 +963,11 @@ class Chain extends Contract {
             try {
                 await this.#executeTransaction({ ...transaction.decoded, hash });
                 block.transactions.push({ hash, ...transaction.decoded });
-                block.fees += Number(calculateFee(transaction.decoded));
-                await accountsStore.put(transaction.decoded.from, new TextEncoder().encode(String(transaction.decoded.nonce)));
+                block.fees = block.fees.add(await calculateFee(transaction.decoded));
+                await globalThis.accountsStore.put(transaction.decoded.from, new TextEncoder().encode(String(transaction.decoded.nonce)));
             }
             catch (e) {
-                await transactionPoolStore.delete(hash);
+                await globalThis.transactionPoolStore.delete(hash);
             }
         }
         // don't add empty block
@@ -955,7 +983,7 @@ class Chain extends Contract {
         //   }
         // }, [])
         const peers = {};
-        for (const entry of peernet.peerEntries) {
+        for (const entry of globalThis.peernet.peerEntries) {
             peers[entry[0]] = entry[1];
         }
         for (const validator of Object.keys(validators)) {
@@ -963,7 +991,7 @@ class Chain extends Contract {
                 const peer = peers[validator];
                 if (peer && peer.connected) {
                     let data = await new BWRequestMessage();
-                    const node = await peernet.prepareMessage(validator, data.encoded);
+                    const node = await globalThis.peernet.prepareMessage(validator, data.encoded);
                     try {
                         const bw = await peer.request(node.encoded);
                         console.log({ bw });
@@ -974,21 +1002,24 @@ class Chain extends Contract {
                     }
                     catch { }
                 }
-                else if (peernet.selectedAccount === validator) {
+                else if (globalThis.peernet.selectedAccount === validator) {
                     block.validators.push({
-                        address: peernet.selectedAccount,
-                        bw: peernet.bw.up + peernet.bw.down
+                        address: globalThis.peernet.selectedAccount,
+                        bw: globalThis.peernet.bw.up + globalThis.peernet.bw.down
                     });
                 }
             }
         }
         console.log({ validators: block.validators });
-        block.reward = 150;
         block.validators = block.validators.map(validator => {
-            validator.reward = String(Number(block.fees) + block.reward / block.validators.length);
+            validator.reward = block.fees;
+            validator.reward = validator.reward.add(block.reward);
+            validator.reward = validator.reward.div(block.validators.length);
+            validator.reward = validator.reward.toString();
             delete validator.bw;
             return validator;
         });
+        console.log({ validators: block.validators });
         // block.validators = calculateValidatorReward(block.validators, block.fees)
         block.index = this.lastBlock?.index;
         if (block.index === undefined)
@@ -997,29 +1028,19 @@ class Chain extends Contract {
             block.index += 1;
         block.previousHash = this.lastBlock?.hash || '0x0';
         block.timestamp = Date.now();
-        const parts = String(block.fees).split('.');
-        let decimals = 0;
-        if (parts[1]) {
-            const potentional = parts[1].split('e');
-            if (potentional[0] === parts[1]) {
-                decimals = parts[1].length;
-            }
-            else {
-                parts[1] = potentional[0];
-                decimals = Number(potentional[1]?.replace(/[+-]/g, '')) + Number(potentional[0].length);
-            }
-        }
-        block.fees = Number.parseFloat(String(block.fees)).toFixed(decimals);
+        block.reward = block.reward.toString();
+        block.fees = block.fees.toString();
         try {
             await Promise.all(block.transactions
-                .map(async (transaction) => transactionPoolStore.delete(transaction.hash)));
+                .map(async (transaction) => globalThis.transactionPoolStore.delete(transaction.hash)));
             let blockMessage = await new BlockMessage(block);
+            blockMessage = await new BlockMessage(blockMessage.encoded);
             const hash = await blockMessage.hash();
-            await peernet.put(hash, blockMessage.encoded, 'block');
+            await globalThis.peernet.put(hash, blockMessage.encoded, 'block');
             await this.#updateState(blockMessage);
-            debug(`created block: ${hash}`);
-            peernet.publish('add-block', blockMessage.encoded);
-            pubsub.publish('add-block', blockMessage.decoded);
+            globalThis.debug(`created block: ${hash}`);
+            globalThis.peernet.publish('add-block', blockMessage.encoded);
+            globalThis.pubsub.publish('add-block', blockMessage.decoded);
         }
         catch (error) {
             throw new Error(`invalid block ${block}`);
@@ -1031,9 +1052,9 @@ class Chain extends Contract {
         try {
             transaction = await new TransactionMessage(transaction);
             const hash = await transaction.hash();
-            const has = await transactionPoolStore.has(hash);
+            const has = await globalThis.transactionPoolStore.has(hash);
             if (!has)
-                await transactionPoolStore.put(hash, transaction.encoded);
+                await globalThis.transactionPoolStore.put(hash, transaction.encoded);
             if (this.#participating && !this.#runningEpoch)
                 this.#runEpoch();
         }
@@ -1066,7 +1087,7 @@ class Chain extends Contract {
      * @param {Address} sender
      * @returns {globalMessage}
      */
-    #createMessage(sender = globalThis.peernet.selectedAccount) {
+    #createMessage(sender = globalThis.globalThis.peernet.selectedAccount) {
         return {
             sender,
             call: this.call,

package/exports/node.js

@@ -12,7 +12,8 @@ class Node {
         network: 'leofcoin:peach',
         networkName: 'leofcoin:peach',
         networkVersion: 'peach',
-        stars: networks.leofcoin.peach.stars
+        stars: networks.leofcoin.peach.stars,
+        autoStart: false
     }, password) {
         this.#node = globalThis.Peernet ? await new globalThis.Peernet(config, password) : await new Peernet(config, password);
         await nodeConfig(config);

package/exports/typings/chain.d.ts

@@ -3,6 +3,8 @@ import Contract from './contract.js';
 import { BigNumberish } from '@ethersproject/bignumber';
 export default class Chain extends Contract {
     #private;
+    id: string;
+    utils: {};
     constructor();
     get nativeMints(): number;
     get nativeBurns(): number;
@@ -26,6 +28,7 @@ export default class Chain extends Contract {
         hash: string;
         previousHash: string;
     }>;
+    triggerSync(): Promise<"already syncing" | "synced">;
     getAndPutBlock(hash: string): BlockMessage;
     resolveBlock(hash: any): any;
     resolveBlocks(): any;
@@ -38,14 +41,14 @@ export default class Chain extends Contract {
     sendTransaction(transaction: any): Promise<{
         hash: any;
         data: any;
-        fee: string | 0;
+        fee: any;
         wait: Promise<unknown>;
         message: any;
     }>;
     addContract(transaction: any, contractMessage: any): Promise<{
         hash: any;
         data: any;
-        fee: string | 0;
+        fee: any;
         wait: Promise<unknown>;
         message: any;
     }>;

package/exports/typings/contract.d.ts

@@ -25,5 +25,6 @@ export default class Contract extends Transaction {
      * @returns
      */
     deployContract(contract: string, constructorParameters?: any[]): Promise<any>;
+    deployContractMessage(message: any): Promise<void>;
 }
 import Transaction from "./transaction.js";

package/exports/typings/node.d.ts

@@ -6,5 +6,6 @@ export default class Node {
         networkName: string;
         networkVersion: string;
         stars: any;
+        autoStart: boolean;
     }, password: string): Promise<this>;
 }

package/exports/typings/transaction.d.ts

@@ -40,7 +40,7 @@ export default class Transaction extends Protocol {
     sendTransaction(message: any): Promise<{
         hash: any;
         data: any;
-        fee: string | 0;
+        fee: any;
         wait: Promise<unknown>;
         message: any;
     }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.4.36",
+  "version": "1.4.38",
   "description": "Official javascript implementation",
   "exports": {
     "./node": "./exports/node.js",
@@ -45,7 +45,9 @@
     "eslint": "^8.28.0",
     "eslint-plugin-unicorn": "^45.0.0",
     "open": "^8.4.0",
+    "rimraf": "^4.4.0",
     "rollup": "^3.12.0",
+    "rollup-plugin-modify": "^3.0.0",
     "tape": "^5.5.2",
     "tslib": "^2.4.1"
   },
@@ -56,7 +58,7 @@
     "@leofcoin/messages": "^1.2.0",
     "@leofcoin/multi-wallet": "^2.1.1",
     "@leofcoin/networks": "^1.0.0",
-    "@leofcoin/peernet": "^1.1.2",
+    "@leofcoin/peernet": "^1.1.12",
     "@leofcoin/peernet-swarm": "^1.0.0",
     "@leofcoin/storage": "^3.0.6",
     "@leofcoin/utils": "^1.1.4",

package/exports/browser/browser-10ffabe1-10ffabe1.js

@@ -1,56 +0,0 @@
-function _mergeNamespaces(n, m) {
-	m.forEach(function (e) {
-		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-			if (k !== 'default' && !(k in n)) {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	});
-	return Object.freeze(n);
-}
-
-var browser$1 = {};
-
-var MediaStream = browser$1.MediaStream = window.MediaStream;
-var MediaStreamTrack = browser$1.MediaStreamTrack = window.MediaStreamTrack;
-var RTCDataChannel = browser$1.RTCDataChannel = window.RTCDataChannel;
-var RTCDataChannelEvent = browser$1.RTCDataChannelEvent = window.RTCDataChannelEvent;
-var RTCDtlsTransport = browser$1.RTCDtlsTransport = window.RTCDtlsTransport;
-var RTCIceCandidate = browser$1.RTCIceCandidate = window.RTCIceCandidate;
-var RTCIceTransport = browser$1.RTCIceTransport = window.RTCIceTransport;
-var RTCPeerConnection = browser$1.RTCPeerConnection = window.RTCPeerConnection;
-var RTCPeerConnectionIceEvent = browser$1.RTCPeerConnectionIceEvent = window.RTCPeerConnectionIceEvent;
-var RTCRtpReceiver = browser$1.RTCRtpReceiver = window.RTCRtpReceiver;
-var RTCRtpSender = browser$1.RTCRtpSender = window.RTCRtpSender;
-var RTCRtpTransceiver = browser$1.RTCRtpTransceiver = window.RTCRtpTransceiver;
-var RTCSctpTransport = browser$1.RTCSctpTransport = window.RTCSctpTransport;
-var RTCSessionDescription = browser$1.RTCSessionDescription = window.RTCSessionDescription;
-var getUserMedia = browser$1.getUserMedia = window.getUserMedia;
-var mediaDevices = browser$1.mediaDevices = navigator.mediaDevices;
-
-var browser = /*#__PURE__*/_mergeNamespaces({
-	__proto__: null,
-	MediaStream: MediaStream,
-	MediaStreamTrack: MediaStreamTrack,
-	RTCDataChannel: RTCDataChannel,
-	RTCDataChannelEvent: RTCDataChannelEvent,
-	RTCDtlsTransport: RTCDtlsTransport,
-	RTCIceCandidate: RTCIceCandidate,
-	RTCIceTransport: RTCIceTransport,
-	RTCPeerConnection: RTCPeerConnection,
-	RTCPeerConnectionIceEvent: RTCPeerConnectionIceEvent,
-	RTCRtpReceiver: RTCRtpReceiver,
-	RTCRtpSender: RTCRtpSender,
-	RTCRtpTransceiver: RTCRtpTransceiver,
-	RTCSctpTransport: RTCSctpTransport,
-	RTCSessionDescription: RTCSessionDescription,
-	default: browser$1,
-	getUserMedia: getUserMedia,
-	mediaDevices: mediaDevices
-}, [browser$1]);
-
-export { browser as b };