Simplify node config + pepecoin bug fix

.dockerignore

@@ -1,8 +1,21 @@
+.DS_Store
+retype.yml
+.vscode
+.github
+.git
+.gitignore
+.husky
+.huskyrc
+.npmignore
+imgs
+README.md
+packages/.DS_Store
+packages/nakamotojs/test
+packages/nakamotojs/ts_src
 packages/node/coverage/
 packages/node/logs/
 packages/node/node_modules/
-packages/node/chain-setup/**/blockchain-data
-packages/node/chain-setup/**/db-data
+packages/node/data/
 packages/node/.env
 packages/node/.DS_Store
 packages/node/src

.gitignore

@@ -1,8 +1,7 @@
 coverage/
 logs/
 node_modules/
-chain-setup/**/blockchain-data
-chain-setup/**/db-data
+data
 .env
 .env.aws
 .docker.config
@@ -14,8 +13,8 @@ error.log
 bcn.config.json
 zmqlog.log
 packages/**/node_modules/
-packages/**/chain-setup/**/blockchain-data/
-packages/**/chain-setup/**/db-data/
+packages/**/data/blockchain-data/
+packages/**/data/db-data/
 # Logs
 logs
 *.log

README.md

@@ -34,10 +34,32 @@ This monorepo contains everything you need to build smart contract based applica
 * [Docs](https://github.com/bitcoin-computer/monorepo/tree/main/packages/docs#readme) - The sources for the documentation
 * [Website](https://github.com/bitcoin-computer/monorepo/tree/main/packages/website#readme) - The sources for the website
 
-## Legal Notice
+## Getting Started
 
-See [here](https://github.com/bitcoin-computer/monorepo/tree/main/packages/lib#legal-notice).
+There are three easy ways to get started with Bitcoin Computer smart contracts:
+
+1. Online example:  See how it works without any installation requirements! [This](https://docs.bitcoincomputer.io/start/) simple example defines, deploys, and executes a smart contract in your browser.
+
+2. Online tools: Try out the Bitcoin Computer functionality directly with our online [Explorer](https://explorer.bitcoincomputer.io) and [Playgorund](https://explorer.bitcoincomputer.io/playground).
+
+3. Local development:
+
+* Clone this monorepo. 
+
+```bash
+git clone https://github.com/bitcoin-computer/monorepo.git
+cd monorepo
+npm install
+```
+
+* Run the applications locally by following the instructions in each application's readme file.
+
+Check the latest version of the Bitcoin Computer monorepo on the [releases](https://github.com/bitcoin-computer/monorepo/releases) page.
 
 ## Getting Help
 
 Have a look at the [docs](https://docs.bitcoincomputer.io/). If you have any questions, please let us know on <a href="https://t.me/thebitcoincomputer" target="_blank">Telegram</a>, <a href="https://twitter.com/TheBitcoinToken" target="_blank">Twitter</a>, or by email clemens@bitcoincomputer.io.
+
+## Legal Notice
+
+See [here](https://github.com/bitcoin-computer/monorepo/tree/main/packages/lib#legal-notice).

package.json

@@ -28,18 +28,10 @@
     "packages/*"
   ],
   "scripts": {
-    "build-node": "docker build -t bitcoin-computer-node .",
     "check-obfuscation": "./scripts/check-obfuscation.sh",
-    "down": "cd packages/node && npm run down",
-    "fund-ltc": "cd packages/node && npm run fund-ltc -- $@",
-    "fund-btc": "cd packages/node && npm run fund-btc -- $@",
     "husky-checks": "./scripts/husky-checks.sh",
     "prepare": "husky install",
-    "prepublishOnly": "./scripts/check-obfuscation.sh",
-    "reset": "cd packages/node && npm run reset",
-    "start": "cd /dist/packages/node && npm run start",
-    "test": "cd packages/node && npm run test; cd ../lib && npm run test",
-    "up": "cd packages/node && npm run up -- $@"
+    "prepublishOnly": "./scripts/check-obfuscation.sh"
   },
   "dependencies": {
     "@endo/static-module-record": "^1.0.4"

packages/TBC20/package.json

@@ -29,7 +29,7 @@
     "prettier": "prettier --write \"src/**/*.{js,jsx,ts,tsx,css,scss,md}\"",
     "types": "tsc",
     "test": "mocha --config .mocharc.json",
-    "test-and-show": "../../scripts/test-and-show.sh tbc20-test.log "
+    "test-and-show": "npm run test 2>&1 | tee tbc20-test.log && open tbc20-test.log"
   },
   "author": "Clemens Ley <clemens@bitcoincomputer.io>",
   "license": "Apache-2.0",

packages/TBC20/src/token.js

@@ -0,0 +1,66 @@
+/* eslint-disable max-classes-per-file */
+const { Contract } = await import('@bitcoin-computer/lib');
+export class Token extends Contract {
+    constructor(to, amount, name, symbol = '') {
+        super({ _owners: [to], amount, name, symbol });
+    }
+    transfer(to, amount) {
+        // Send entire amount
+        if (typeof amount === 'undefined') {
+            this._owners = [to];
+            return null;
+        }
+        // Send partial amount in a new object
+        if (this.amount >= amount) {
+            this.amount -= amount;
+            return new Token(to, amount, this.name, this.symbol);
+        }
+        throw new Error('Insufficient funds');
+    }
+}
+export class TBC20 {
+    constructor(computer, mod) {
+        this.computer = computer;
+        this.mod = mod;
+    }
+    async deploy() {
+        this.mod = await this.computer.deploy(`export ${Token}`);
+        return this.mod;
+    }
+    async mint(publicKey, amount, name, symbol) {
+        const args = [publicKey, amount, name, symbol];
+        const token = await this.computer.new(Token, args, this.mod);
+        return token._root;
+    }
+    async totalSupply(root) {
+        const rootBag = await this.computer.sync(root);
+        return rootBag.amount;
+    }
+    async getBags(publicKey, root) {
+        const revs = await this.computer.query({ publicKey, mod: this.mod });
+        const bags = await Promise.all(revs.map(async (rev) => this.computer.sync(rev)));
+        return bags.flatMap((bag) => (bag._root === root ? [bag] : []));
+    }
+    async balanceOf(publicKey, root) {
+        if (typeof root === 'undefined')
+            throw new Error('Please pass a root into balanceOf.');
+        const bags = await this.getBags(publicKey, root);
+        return bags.reduce((prev, curr) => prev + curr.amount, 0);
+    }
+    async transfer(to, amount, root) {
+        let _amount = amount;
+        const owner = this.computer.getPublicKey();
+        const bags = await this.getBags(owner, root);
+        const results = [];
+        while (_amount > 0 && bags.length > 0) {
+            const [bag] = bags.splice(0, 1);
+            const available = Math.min(_amount, bag.amount);
+            // eslint-disable-next-line no-await-in-loop
+            results.push(await bag.transfer(to, available));
+            _amount -= available;
+        }
+        if (_amount > 0)
+            throw new Error('Could not send entire amount');
+        await Promise.all(results);
+    }
+}

packages/TBC20/test/token.test.js

@@ -0,0 +1,163 @@
+/* eslint-disable no-unused-expressions */
+import { expect } from 'chai';
+import { Computer } from '@bitcoin-computer/lib';
+import dotenv from 'dotenv';
+import { TBC20, Token } from '../src/token';
+dotenv.config({ path: '../node/.env' });
+const url = process.env.BCN_URL;
+const chain = process.env.BCN_CHAIN;
+const network = process.env.BCN_NETWORK;
+function sleep(delay) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, delay);
+    });
+}
+const sender = new Computer({ url, chain, network });
+const receiver = new Computer({ url, chain, network });
+before(async () => {
+    await sender.faucet(1e7);
+});
+describe('Token', () => {
+    describe('Using fungible tokens without a helper class', () => {
+        let token;
+        describe('Minting a fungible token', async () => {
+            it('Sender mints a token', async () => {
+                token = await sender.new(Token, [sender.getPublicKey(), 3, 'test']);
+            });
+            it('The meta data should be set', async () => {
+                expect(token.amount).to.eq(3);
+                expect(token._owners).deep.equal([sender.getPublicKey()]);
+                expect(token.name).to.eq('test');
+                expect(token.symbol).to.eq('');
+                expect(token._id).to.be.a('string');
+                expect(token._rev).to.be.a('string');
+                expect(token._root).to.be.a('string');
+            });
+        });
+        describe('Transferring the NFT', () => {
+            let newToken;
+            it('Sender transfers the NFT to receiver', async () => {
+                newToken = await token.transfer(receiver.getPublicKey(), 1);
+            });
+            it('The meta data of token should be set correctly', () => {
+                expect(token.amount).to.eq(2);
+                expect(token._owners).deep.equal([sender.getPublicKey()]);
+                expect(token.name).to.eq('test');
+                expect(token.symbol).to.eq('');
+                expect(token._id).to.be.a('string');
+                expect(token._rev).to.be.a('string');
+                expect(token._root).to.be.a('string');
+            });
+            it('The meta data of newToken should be set correctly', () => {
+                expect(newToken.amount).to.eq(1);
+                expect(newToken._owners).deep.equal([receiver.getPublicKey()]);
+                expect(newToken.name).to.eq('test');
+                expect(newToken.symbol).to.eq('');
+                expect(newToken._id).to.be.a('string');
+                expect(newToken._rev).to.be.a('string');
+                expect(newToken._root).to.be.a('string');
+            });
+        });
+    });
+    describe('Using fungible tokens with a helper class', () => {
+        describe('mint', () => {
+            const tbc20 = new TBC20(sender);
+            let root;
+            it('Should create the tbc20 object', async () => {
+                const publicKey = tbc20.computer.getPublicKey();
+                root = await tbc20.mint(publicKey, 200, 'test', 'TST');
+                expect(root).not.to.be.undefined;
+                expect(typeof root).to.eq('string');
+                expect(root.length).to.be.greaterThan(64);
+            });
+            it('Should mint a root token', async () => {
+                const rootToken = await sender.sync(root);
+                expect(rootToken).not.to.be.undefined;
+                expect(rootToken._id).to.eq(root);
+                expect(rootToken._rev).to.eq(root);
+                expect(rootToken._root).to.eq(root);
+                expect(rootToken.amount).to.eq(200);
+                expect(rootToken.name).to.eq('test');
+                expect(rootToken.symbol).to.eq('TST');
+            });
+        });
+        describe('totalSupply', () => {
+            it('Should return the supply of tokens', async () => {
+                const tbc20 = new TBC20(sender);
+                const publicKey = tbc20.computer.getPublicKey();
+                const root = await tbc20.mint(publicKey, 200, 'test', 'TST');
+                const supply = await tbc20.totalSupply(root);
+                expect(supply).to.eq(200);
+            });
+        });
+        describe('balanceOf', () => {
+            it('Should throw an error if the root is not set', async () => {
+                const publicKeyString = sender.getPublicKey();
+                const tbc20 = new TBC20(sender);
+                expect(tbc20).not.to.be.undefined;
+                try {
+                    await tbc20.balanceOf(publicKeyString, undefined);
+                    expect(true).to.eq(false);
+                }
+                catch (err) {
+                    expect(err.message).to.eq('Please pass a root into balanceOf.');
+                }
+            });
+            it('Should compute the balance', async () => {
+                const tbc20 = new TBC20(sender);
+                const publicKey = tbc20.computer.getPublicKey();
+                const root = await tbc20.mint(publicKey, 200, 'test', 'TST');
+                await sleep(200);
+                const res = await tbc20.balanceOf(publicKey, root);
+                expect(res).to.eq(200);
+            });
+        });
+        describe('transfer', () => {
+            it('Should transfer a token', async () => {
+                const computer2 = new Computer({ url, chain, network });
+                const tbc20 = new TBC20(sender);
+                const publicKey = tbc20.computer.getPublicKey();
+                const root = await tbc20.mint(publicKey, 200, 'test', 'TST');
+                await sleep(200);
+                await tbc20.transfer(computer2.getPublicKey(), 20, root);
+                await sleep(200);
+                const res = await tbc20.balanceOf(publicKey, root);
+                expect(res).to.eq(180);
+            });
+            it('Should transfer random amounts to different people', async () => {
+                const computer2 = new Computer({ url, chain, network });
+                const computer3 = new Computer({ url, chain, network });
+                const tbc20 = new TBC20(sender);
+                const publicKey = tbc20.computer.getPublicKey();
+                const root = await tbc20.mint(publicKey, 200, 'multiple', 'MULT');
+                const amount2 = Math.floor(Math.random() * 100);
+                const amount3 = Math.floor(Math.random() * 100);
+                await sleep(200);
+                await tbc20.transfer(computer2.getPublicKey(), amount2, root);
+                await sleep(200);
+                await tbc20.transfer(computer3.getPublicKey(), amount3, root);
+                await sleep(200);
+                const res = await tbc20.balanceOf(publicKey, root);
+                expect(res).to.eq(200 - amount2 - amount3);
+                const res2 = await tbc20.balanceOf(computer2.getPublicKey(), root);
+                expect(res2).to.eq(amount2);
+                const res3 = await tbc20.balanceOf(computer3.getPublicKey(), root);
+                expect(res3).to.eq(amount3);
+            });
+            it('Should fail if the amount is greater than the balance', async () => {
+                const computer2 = new Computer({ url, chain, network });
+                const tbc20 = new TBC20(sender);
+                const publicKey = tbc20.computer.getPublicKey();
+                const root = await tbc20.mint(publicKey, 200, 'test', 'TST');
+                await sleep(200);
+                try {
+                    await tbc20.transfer(computer2.getPublicKey(), 201, root);
+                    expect(true).to.eq('false');
+                }
+                catch (err) {
+                    expect(err.message).to.eq('Could not send entire amount');
+                }
+            });
+        });
+    });
+});

packages/TBC20/test/token.test.ts

@@ -4,18 +4,20 @@ import { Computer } from '@bitcoin-computer/lib'
 import dotenv from 'dotenv'
 import { TBC20, Token } from '../src/token'
 
-dotenv.config({ path: '../../.env' })
+dotenv.config({ path: '../node/.env' })
 
 const url = process.env.BCN_URL
+const chain = process.env.BCN_CHAIN
+const network = process.env.BCN_NETWORK
 
 function sleep(delay: number): Promise<void> {
   return new Promise((resolve) => {
     setTimeout(resolve, delay)
   })
 }
 
-const sender = new Computer({ url })
-const receiver = new Computer({ url })
+const sender = new Computer({ url, chain, network })
+const receiver = new Computer({ url, chain, network })
 
 before(async () => {
   await sender.faucet(1e7)
@@ -130,7 +132,7 @@ describe('Token', () => {
 
     describe('transfer', () => {
       it('Should transfer a token', async () => {
-        const computer2 = new Computer()
+        const computer2 = new Computer({ url, chain, network })
         const tbc20 = new TBC20(sender)
         const publicKey = tbc20.computer.getPublicKey()
         const root = await tbc20.mint(publicKey, 200, 'test', 'TST')
@@ -142,8 +144,8 @@ describe('Token', () => {
       })
 
       it('Should transfer random amounts to different people', async () => {
-        const computer2 = new Computer()
-        const computer3 = new Computer()
+        const computer2 = new Computer({ url, chain, network })
+        const computer3 = new Computer({ url, chain, network })
         const tbc20 = new TBC20(sender)
         const publicKey = tbc20.computer.getPublicKey()
         const root = await tbc20.mint(publicKey, 200, 'multiple', 'MULT')
@@ -165,7 +167,7 @@ describe('Token', () => {
       })
 
       it('Should fail if the amount is greater than the balance', async () => {
-        const computer2 = new Computer()
+        const computer2 = new Computer({ url, chain, network })
         const tbc20 = new TBC20(sender)
         const publicKey = tbc20.computer.getPublicKey()
         const root = await tbc20.mint(publicKey, 200, 'test', 'TST')