saito-js 0.0.2 → 0.0.3

package/.github/workflows/publish.yml

@@ -0,0 +1,46 @@
+name: publish
+
+on:
+  push:
+    branches: [ prod, master ]
+  pull_request:
+    branches: [ develop, master ]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repo
+        uses: actions/Checkout@v3
+
+      - name: setup node
+        uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
+          cache: npm
+      #          cache-dependency-path: saito-wasm/package-lock.json
+
+      - name: get latest version
+        run: |
+          echo latest_version=$(npm show saito-js version) >> $GITHUB_ENV
+          echo current_version=$(npm pkg get version) >> $GITHUB_ENV
+      #        working-directory: saito-wasm
+      - name: version check
+        if: ${{ env.latest_version == env.current_version }}
+        run: |
+          echo "same version is already published"
+          echo "current version : ${{ env.current_version }}"
+          echo "published version : ${{ env.latest_version }}"
+
+      - name: Install npm packages
+        if: ${{ env.latest_version != env.current_version }}
+        run: npm ci
+      #        working-directory: saito-wasm
+
+      - name: Publish package
+        if: ${{ env.latest_version != env.current_version }}
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+#        working-directory: saito-wasm

package/.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "printWidth": 100
+}

package/index.node.ts

@@ -1,4 +1,4 @@
-import Saito from './saito';
+import Saito from "./saito";
 import SharedMethods from "./shared_methods";
 import Configs from "./configs";
 import Transaction from "./lib/transaction";
@@ -6,35 +6,46 @@ import Slip from "./lib/slip";
 import Block from "./lib/block";
 import Peer from "./lib/peer";
 import Factory from "./lib/factory";
+import Wallet from "./lib/wallet";
+import Blockchain from "./lib/blockchain";
 
-let cr = require('crypto');
-globalThis.crypto = cr.webcrypto;
-
+const NODE_MAJOR_VERSION = parseInt(process.versions.node.split(".")[0]);
+if (NODE_MAJOR_VERSION < 20) {
+  let cr = require("crypto");
+  globalThis.crypto = cr.webcrypto;
+}
 
 /**
  *
  * @param configs
  * @param sharedMethods
  */
-export async function initialize(configs: Configs, sharedMethods: SharedMethods, factory: Factory) {
-    if (Saito.getLibInstance()) {
-        console.error("saito already initialized");
-        return;
-    }
-    console.log("initializing saito-js");
-    let saito = await import("saito-wasm/dist/server");
-    console.log("wasm lib loaded");
-
-    let s = await saito.default;
-
-    Saito.setLibInstance(s);
-
-    Transaction.Type = s.WasmTransaction;
-    Slip.Type = s.WasmSlip;
-    Block.Type = s.WasmBlock;
-    Peer.Type = s.WasmPeer;
-
-    return Saito.initialize(configs, sharedMethods, factory);
+export async function initialize(
+  configs: Configs,
+  sharedMethods: SharedMethods,
+  factory: Factory,
+  privateKey: string
+) {
+  if (Saito.getLibInstance()) {
+    console.error("saito already initialized");
+    return;
+  }
+  console.log("initializing saito-js");
+  let saito = await import("saito-wasm/dist/server");
+  console.log("wasm lib loaded");
+
+  let s = await saito.default;
+
+  Saito.setLibInstance(s);
+
+  Transaction.Type = s.WasmTransaction;
+  Slip.Type = s.WasmSlip;
+  Block.Type = s.WasmBlock;
+  Peer.Type = s.WasmPeer;
+  Wallet.Type = s.WasmWallet;
+  Blockchain.Type = s.WasmBlockchain;
+
+  return Saito.initialize(configs, sharedMethods, factory, privateKey);
 }
 
 export default Saito;

package/index.web.ts

@@ -1,4 +1,4 @@
-import Saito from './saito';
+import Saito from "./saito";
 import SharedMethods from "./shared_methods";
 import Configs from "./configs";
 import Transaction from "./lib/transaction";
@@ -6,36 +6,42 @@ import Slip from "./lib/slip";
 import Block from "./lib/block";
 import Peer from "./lib/peer";
 import Factory from "./lib/factory";
+import Wallet from "./lib/wallet";
+import Blockchain from "./lib/blockchain";
 
 /**
  *
  * @param configs
  * @param sharedMethods
  */
-export async function initialize(configs: Configs, sharedMethods: SharedMethods, factory: Factory) {
-    if (Saito.getLibInstance()) {
-        console.error("saito already initialized");
-        return;
-    }
-    console.log("initializing saito-js");
+export async function initialize(
+  configs: Configs,
+  sharedMethods: SharedMethods,
+  factory: Factory,
+  privateKey: string
+) {
+  if (Saito.getLibInstance()) {
+    console.error("saito already initialized");
+    return;
+  }
+  console.log("initializing saito-js");
 
-    return import("saito-wasm/dist/browser")
-        .then((s: any) => {
-            return s.default;
-        })
-        .then((s) => {
-            Saito.setLibInstance(s);
-            return s.default()
-                .then(() => {
-
-                    Transaction.Type = s.WasmTransaction;
-                    Slip.Type = s.WasmSlip;
-                    Block.Type = s.WasmBlock;
-                    Peer.Type = s.WasmPeer;
-                    return Saito.initialize(configs, sharedMethods, factory);
-                });
-        });
+  return import("saito-wasm/dist/browser")
+    .then((s: any) => {
+      return s.default;
+    })
+    .then((s) => {
+      Saito.setLibInstance(s);
+      return s.default().then(() => {
+        Transaction.Type = s.WasmTransaction;
+        Slip.Type = s.WasmSlip;
+        Block.Type = s.WasmBlock;
+        Peer.Type = s.WasmPeer;
+        Wallet.Type = s.WasmWallet;
+        Blockchain.Type = s.WasmBlockchain;
+        return Saito.initialize(configs, sharedMethods, factory, privateKey);
+      });
+    });
 }
 
-
 export default Saito;

package/lib/blockchain.ts

@@ -0,0 +1,14 @@
+import type {WasmBlockchain} from "saito-wasm/dist/types/pkg/node/index_bg";
+
+export default class Blockchain {
+    protected blockchain: WasmBlockchain;
+    public static Type: any;
+
+    constructor(blockchain: WasmBlockchain) {
+        this.blockchain = blockchain;
+    }
+
+    public async reset() {
+        return this.blockchain.reset();
+    }
+}

package/lib/custom/custom_shared_methods.ts

@@ -0,0 +1,92 @@
+import SharedMethods from "../../shared_methods";
+import Saito from "../../saito";
+import Wallet from "../wallet";
+import Blockchain from "../blockchain";
+
+export default class CustomSharedMethods implements SharedMethods {
+  processApiCall(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+
+  connectToPeer(peerData: any): void {
+    throw new Error("Method not implemented.");
+  }
+
+  disconnectFromPeer(peerIndex: bigint): void {
+    throw new Error("Method not implemented.");
+  }
+
+  fetchBlockFromPeer(url: string): Promise<Uint8Array> {
+    throw new Error("Method not implemented.");
+  }
+
+  isExistingFile(key: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+
+  loadBlockFileList(): Array<string> {
+    throw new Error("Method not implemented.");
+  }
+
+  processApiError(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): void {
+    let promise = Saito.getInstance().promises.get(msgIndex);
+    if (promise) {
+      promise.reject(buffer);
+    } else {
+      console.error(
+        "callback not found for callback index : " + msgIndex + " from peer : " + peerIndex
+      );
+    }
+  }
+
+  processApiSuccess(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): void {
+    let promise = Saito.getInstance().promises.get(msgIndex);
+    if (promise) {
+      promise.resolve(buffer);
+    } else {
+      console.error(
+        "callback not found for callback index : " + msgIndex + " from peer : " + peerIndex
+      );
+    }
+  }
+
+  readValue(key: string): Uint8Array | null {
+    throw new Error("Method not implemented.");
+  }
+
+  removeValue(key: string): void {
+    throw new Error("Method not implemented.");
+  }
+
+  sendMessage(peerIndex: bigint, buffer: Uint8Array): void {
+    throw new Error("Method not implemented.");
+  }
+
+  sendMessageToAll(buffer: Uint8Array, exceptions: Array<bigint>): void {
+    throw new Error("Method not implemented.");
+  }
+
+  writeValue(key: string, value: Uint8Array): void {
+    throw new Error("Method not implemented.");
+  }
+
+  sendInterfaceEvent(event: String, peerIndex: bigint): void {
+    throw new Error("Method not implemented.");
+  }
+
+  saveWallet(): void {
+    throw new Error("Method not implemented.");
+  }
+
+  loadWallet(): void {
+    throw new Error("Method not implemented.");
+  }
+
+  saveBlockchain(): void {
+    throw new Error("Method not implemented.");
+  }
+
+  loadBlockchain(): void {
+    throw new Error("Method not implemented.");
+  }
+}

package/lib/custom/shared_methods.web.ts

@@ -1,5 +1,6 @@
 import Saito from "../../saito";
-import CustomSharedMethods from "./shared_methods.custom";
+
+import CustomSharedMethods from "./custom_shared_methods";
 
 export default class WebSharedMethods extends CustomSharedMethods {
     connectToPeer(peerData: any): void {

package/lib/factory.ts

@@ -2,24 +2,31 @@ import Block from "./block";
 import Transaction from "./transaction";
 import Slip from "./slip";
 import Peer from "./peer";
+import Wallet from "./wallet";
+import Blockchain from "./blockchain";
 
 export default class Factory {
-    constructor() {
-    }
+  constructor() {}
 
-    public createBlock(data?: any): Block {
-        return new Block(data);
-    }
+  public createBlock(data?: any): Block {
+    return new Block(data);
+  }
 
-    public createTransaction<T extends Transaction>(data?: any): Transaction {
-        return new Transaction(data);
-    }
+  public createTransaction<T extends Transaction>(data?: any): Transaction {
+    return new Transaction(data);
+  }
 
-    public createSlip(data?: any): Slip {
-        return new Slip(data);
-    }
+  public createSlip(data?: any): Slip {
+    return new Slip(data);
+  }
 
-    public createPeer(data?: any): Peer {
-        return new Peer(data);
-    }
+  public createPeer(data?: any): Peer {
+    return new Peer(data);
+  }
+  public createWallet(data: any): Wallet {
+    return new Wallet(data);
+  }
+  public createBlockchain(data: any): Blockchain {
+    return new Blockchain(data);
+  }
 }

package/lib/slip.ts

@@ -49,8 +49,8 @@ export default class Slip {
         return this.slip.amount;
     }
 
-    public set amount(amount: bigint) {
-        this.slip.amount = amount;
+    public set amount(amount: bigint | number) {
+        this.slip.amount = BigInt(amount);
     }
 
     public get publicKey(): string {

package/lib/transaction.ts

@@ -1,4 +1,4 @@
-import type {WasmTransaction} from 'saito-wasm/dist/types/pkg/node/index_bg';
+import type {WasmTransaction} from "saito-wasm/dist/types/pkg/node/index_bg";
 import Slip from "./slip";
 import Saito from "../saito";
 import Factory from "./factory";
@@ -56,13 +56,13 @@ export default class Transaction {
     }
 
     public get to(): Array<Slip> {
-        return this.tx.to.map(slip => {
+        return this.tx.to.map((slip) => {
             return Saito.getInstance().factory.createSlip(slip);
         });
     }
 
     public get from(): Array<Slip> {
-        return this.tx.from.map(slip => {
+        return this.tx.from.map((slip) => {
             return Saito.getInstance().factory.createSlip(slip);
         });
     }
@@ -111,8 +111,12 @@ export default class Transaction {
         return this.tx.total_fees;
     }
 
-    public sign() {
-        Saito.getInstance().signTransaction(this);
+    public async sign() {
+        return this.tx.sign();
+    }
+
+    public async signAndEncrypt() {
+        return this.tx.sign_and_encrypt();
     }
 
     public isFrom(key: string): boolean {
@@ -138,10 +142,8 @@ export default class Transaction {
     }
 
     public static deserialize(buffer: Uint8Array, factory: Factory): Transaction | null {
-        console.log("1111");
         try {
             let wasmTx = Transaction.Type.deserialize(buffer);
-            console.log("2222");
             return factory.createTransaction(wasmTx);
         } catch (e) {
             console.debug(e);
@@ -149,6 +151,10 @@ export default class Transaction {
         }
     }
 
+    public serialize(): Uint8Array {
+        return this.tx.serialize();
+    }
+
     public packData() {
         if (Object.keys(this.msg).length === 0) {
             this.data = new Uint8Array(Buffer.alloc(0));

package/lib/wallet.ts

@@ -0,0 +1,61 @@
+import type { WasmWallet } from "saito-wasm/dist/types/pkg/node/index_bg";
+import Saito from "../saito";
+
+export const DefaultEmptyPrivateKey =
+  "0000000000000000000000000000000000000000000000000000000000000000";
+export const DefaultEmptyPublicKey =
+  "000000000000000000000000000000000000000000000000000000000000000000";
+
+export default class Wallet {
+  protected wallet: WasmWallet;
+  public static Type: any;
+
+  constructor(wallet: WasmWallet) {
+    this.wallet = wallet;
+  }
+
+  public async save() {
+    return this.wallet.save();
+  }
+
+  public async load() {
+    return this.wallet.load();
+  }
+
+  public async reset() {
+    return this.wallet.reset();
+  }
+
+  public async getPublicKey() {
+    let key = await this.wallet.get_public_key();
+    return key === DefaultEmptyPublicKey ? "" : key;
+  }
+
+  public async setPublicKey(key: string) {
+    if (key === "") {
+      key = DefaultEmptyPublicKey;
+    }
+    return this.wallet.set_public_key(key);
+  }
+
+  public async getPrivateKey() {
+    let key = await this.wallet.get_private_key();
+    return key === DefaultEmptyPrivateKey ? "" : key;
+  }
+
+  public async setPrivateKey(key: string) {
+    if (key === "") {
+      key = DefaultEmptyPrivateKey;
+    }
+    return this.wallet.set_private_key(key);
+  }
+
+  public async getBalance() {
+    return this.wallet.get_balance();
+  }
+
+  public async getPendingTxs() {
+    let txs = await this.wallet.get_pending_txs();
+    return txs.map((tx: any) => Saito.getInstance().factory.createTransaction(tx));
+  }
+}

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "saito-js",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "js wrappings around saito-core using wasm",
   "scripts": {
     "test": "env TS_NODE_PROJECT=\"tsconfig.testing.json\" mocha --require ts-node/register 'tests/**/*.ts'",
+    "build prod": "webpack --config webpack.prod.config.js",
     "build": "webpack",
     "serve": "webpack-dev-server"
   },
@@ -23,6 +24,7 @@
     "html-webpack-plugin": "^5.5.0",
     "ignore-loader": "^0.1.2",
     "path-browserify": "^1.0.1",
+    "prettier": "^2.8.8",
     "source-map-loader": "^3.0.0",
     "stream-browserify": "^3.0.0",
     "ts-loader": "^9.4.2",
@@ -35,6 +37,7 @@
   "dependencies": {
     "buffer": "^6.0.3",
     "cookie-parser": "~1.4.6",
+    "saito-wasm": "^0.0.3",
     "cors": "^2.8.5",
     "debug": "~4.3.4",
     "express": "~4.18.2",

package/saito.ts

@@ -3,6 +3,8 @@ import Transaction from "./lib/transaction";
 import Block from "./lib/block";
 import Factory from "./lib/factory";
 import Peer from "./lib/peer";
+import Wallet, {DefaultEmptyPrivateKey} from "./lib/wallet";
+import Blockchain from "./lib/blockchain";
 
 // export enum MessageType {
 //     HandshakeChallenge = 1,
@@ -31,9 +33,15 @@ export default class Saito {
     factory = new Factory();
     promises = new Map<number, any>();
     private callbackIndex: number = 1;
-
-
-    public static async initialize(configs: any, sharedMethods: SharedMethods, factory = new Factory()) {
+    private wallet: Wallet | null = null;
+    private blockchain: Blockchain | null = null;
+
+    public static async initialize(
+        configs: any,
+        sharedMethods: SharedMethods,
+        factory = new Factory(),
+        privateKey: string
+    ) {
         this.instance = new Saito(factory);
 
         // @ts-ignore
@@ -69,11 +77,10 @@ export default class Saito {
                 console.log("fetching block : " + url);
                 sharedMethods.fetchBlockFromPeer(url).then((buffer: Uint8Array) => {
                     Saito.getLibInstance().process_fetched_block(buffer, hash, peer_index);
-                })
+                });
             },
             process_api_call: (buffer: Uint8Array, msgIndex: number, peerIndex: bigint) => {
                 return sharedMethods.processApiCall(buffer, msgIndex, peerIndex).then(() => {
-
                 });
             },
             process_api_success: (buffer: Uint8Array, msgIndex: number, peerIndex: bigint) => {
@@ -84,10 +91,24 @@ export default class Saito {
             },
             send_interface_event: (event: string, peerIndex: bigint) => {
                 return sharedMethods.sendInterfaceEvent(event, peerIndex);
-            }
+            },
+            save_wallet: (wallet: any) => {
+                return sharedMethods.saveWallet(wallet);
+            },
+            load_wallet: (wallet: any) => {
+                return sharedMethods.loadWallet(wallet);
+            },
+            save_blockchain: (blockchain: any) => {
+                return sharedMethods.saveBlockchain(blockchain);
+            },
+            load_blockchain: (blockchain: any) => {
+                return sharedMethods.loadBlockchain(blockchain);
+            },
         };
-
-        await Saito.getLibInstance().initialize(JSON.stringify(configs));
+        if (privateKey === "") {
+            privateKey = DefaultEmptyPrivateKey;
+        }
+        await Saito.getLibInstance().initialize(JSON.stringify(configs), privateKey);
 
         console.log("saito initialized");
 
@@ -142,13 +163,13 @@ export default class Saito {
         return Saito.getInstance().factory.createBlock(block) as B;
     }
 
-    public async getPublicKey(): Promise<string> {
-        return Saito.getLibInstance().get_public_key();
-    }
-
-    public async getPrivateKey(): Promise<string> {
-        return Saito.getLibInstance().get_private_key();
-    }
+    // public async getPublicKey(): Promise<string> {
+    //     return Saito.getLibInstance().get_public_key();
+    // }
+    //
+    // public async getPrivateKey(): Promise<string> {
+    //     return Saito.getLibInstance().get_private_key();
+    // }
 
     public async processNewPeer(index: bigint, peer_config: any): Promise<void> {
         return Saito.getLibInstance().process_new_peer(index, peer_config);
@@ -162,7 +183,11 @@ export default class Saito {
         return Saito.getLibInstance().process_msg_buffer_from_peer(buffer, peer_index);
     }
 
-    public async processFetchedBlock(buffer: Uint8Array, hash: Uint8Array, peer_index: bigint): Promise<void> {
+    public async processFetchedBlock(
+        buffer: Uint8Array,
+        hash: Uint8Array,
+        peer_index: bigint
+    ): Promise<void> {
         return Saito.getLibInstance().process_fetched_block(buffer, hash, peer_index);
     }
 
@@ -188,31 +213,35 @@ export default class Saito {
         fee = BigInt(0),
         force_merge = false
     ): Promise<T> {
-        let wasmTx = await Saito.getLibInstance().create_transaction(publickey, amount, fee, force_merge);
+        let wasmTx = await Saito.getLibInstance().create_transaction(
+            publickey,
+            amount,
+            fee,
+            force_merge
+        );
         let tx = Saito.getInstance().factory.createTransaction(wasmTx) as T;
         tx.timestamp = new Date().getTime();
-        console.log("wwwwwwwwwww : " + tx.timestamp);
         return tx;
     }
 
-    public async signTransaction(tx: Transaction): Promise<Transaction> {
-        tx.packData();
-        await tx.wasmTransaction.sign();
-        return tx;
-    }
+    // public async signTransaction(tx: Transaction): Promise<Transaction> {
+    //   tx.packData();
+    //   await tx.wasmTransaction.sign();
+    //   return tx;
+    // }
 
-    public async getPendingTransactions<Tx extends Transaction>(): Promise<Array<Tx>> {
-        let txs = await Saito.getLibInstance().get_pending_txs();
-        return txs.map((tx: any) => Saito.getInstance().factory.createTransaction(tx));
-    }
+    // public async getPendingTransactions<Tx extends Transaction>(): Promise<Array<Tx>> {
+    //     let txs = await Saito.getLibInstance().get_pending_txs();
+    //     return txs.map((tx: any) => Saito.getInstance().factory.createTransaction(tx));
+    // }
 
-    public async signAndEncryptTransaction(tx: Transaction) {
-        return tx.wasmTransaction.sign_and_encrypt();
-    }
+    // public async signAndEncryptTransaction(tx: Transaction) {
+    //     return tx.wasmTransaction.sign_and_encrypt();
+    // }
 
-    public async getBalance(): Promise<bigint> {
-        return Saito.getLibInstance().get_balance();
-    }
+    // public async getBalance(): Promise<bigint> {
+    //     return Saito.getLibInstance().get_balance();
+    // }
 
     public async getPeers(): Promise<Array<Peer>> {
         let peers = await Saito.getLibInstance().get_peers();
@@ -221,7 +250,6 @@ export default class Saito {
         });
     }
 
-
     public async getPeer(index: bigint): Promise<Peer | null> {
         let peer = await Saito.getLibInstance().get_peer(index);
         if (!peer) {
@@ -242,14 +270,18 @@ export default class Saito {
         return Saito.getLibInstance().propagate_transaction(tx.wasmTransaction);
     }
 
-    public async sendApiCall(buffer: Uint8Array, peerIndex: bigint, waitForReply: boolean): Promise<Uint8Array> {
+    public async sendApiCall(
+        buffer: Uint8Array,
+        peerIndex: bigint,
+        waitForReply: boolean
+    ): Promise<Uint8Array> {
         console.log("saito.sendApiCall : peer = " + peerIndex + " wait for reply = " + waitForReply);
         let callbackIndex = this.callbackIndex++;
         if (waitForReply) {
             return new Promise((resolve, reject) => {
                 this.promises.set(callbackIndex, {
                     resolve,
-                    reject
+                    reject,
                 });
                 Saito.getLibInstance().send_api_call(buffer, callbackIndex, peerIndex);
             });
@@ -266,12 +298,25 @@ export default class Saito {
         await Saito.getLibInstance().send_api_error(buffer, msgId, peerIndex);
     }
 
-    public async sendTransactionWithCallback(transaction: Transaction, callback?: any, peerIndex?: bigint): Promise<any> {
+    public async sendTransactionWithCallback(
+        transaction: Transaction,
+        callback?: any,
+        peerIndex?: bigint
+    ): Promise<any> {
         // TODO : implement retry on fail
         // TODO : stun code goes here probably???
-        console.log("saito.sendTransactionWithCallback : peer = " + peerIndex + " sig = " + transaction.signature);
+        console.log(
+            "saito.sendTransactionWithCallback : peer = " + peerIndex + " sig = " + transaction.signature
+        );
         let buffer = transaction.wasmTransaction.serialize();
-        console.log("sendTransactionWithCallback : " + peerIndex + " with length : " + buffer.byteLength + " sent : ", transaction.msg);
+        console.log(
+            "sendTransactionWithCallback : " +
+            peerIndex +
+            " with length : " +
+            buffer.byteLength +
+            " sent : ",
+            transaction.msg
+        );
         await this.sendApiCall(buffer, peerIndex || BigInt(0), !!callback)
             .then((buffer: Uint8Array) => {
                 if (callback) {
@@ -300,23 +345,60 @@ export default class Saito {
     }
 
     public async propagateServices(peerIndex: bigint, services: string[]) {
-        return Saito.getLibInstance().propagateServices(peerIndex, services);
+        return Saito.getLibInstance().propagate_services(peerIndex, services);
     }
 
-    public async sendRequest(message: string, data: any = "", callback?: any, peerIndex?: bigint): Promise<any> {
+    public async sendRequest(
+        message: string,
+        data: any = "",
+        callback?: any,
+        peerIndex?: bigint
+    ): Promise<any> {
         console.log("saito.sendRequest : peer = " + peerIndex);
-        let publicKey = await this.getPublicKey();
+        let wallet = await this.getWallet();
+        let publicKey = await wallet.getPublicKey();
         let tx = await this.createTransaction(publicKey, BigInt(0), BigInt(0));
         tx.msg = {
             request: message,
             data: data,
         };
         tx.packData();
-        return this.sendTransactionWithCallback(tx, (tx: Transaction) => {
-            if (callback) {
-                return callback(tx.msg);
-            }
-        }, peerIndex);
+        return this.sendTransactionWithCallback(
+            tx,
+            (tx: Transaction) => {
+                if (callback) {
+                    return callback(tx.msg);
+                }
+            },
+            peerIndex
+        );
     }
-}
 
+    public async getWallet() {
+        if (!this.wallet) {
+            let w = await Saito.getLibInstance().get_wallet();
+            this.wallet = this.factory.createWallet(w);
+        }
+        return this.wallet;
+    }
+
+    public async getBlockchain() {
+        if (!this.blockchain) {
+            let b = await Saito.getLibInstance().get_blockchain();
+            this.blockchain = this.factory.createBlockchain(b);
+        }
+        return this.blockchain;
+    }
+
+    // public async loadWallet() {
+    //     return Saito.getLibInstance().load_wallet();
+    // }
+    //
+    // public async saveWallet() {
+    //     return Saito.getLibInstance().save_wallet();
+    // }
+    //
+    // public async resetWallet() {
+    //     return Saito.getLibInstance().reset_wallet();
+    // }
+}

package/shared_methods.ts

@@ -1,3 +1,6 @@
+import Wallet from "./lib/wallet";
+import Blockchain from "./lib/blockchain";
+
 export default interface SharedMethods {
     sendMessage(peerIndex: bigint, buffer: Uint8Array): void;
 
@@ -27,4 +30,11 @@ export default interface SharedMethods {
 
     sendInterfaceEvent(event: String, peerIndex: bigint): void;
 
+    saveWallet(wallet: Wallet): void;
+
+    loadWallet(wallet: Wallet): void;
+
+    saveBlockchain(blockchain: Blockchain): void;
+
+    loadBlockchain(blockchain: Blockchain): void;
 }

package/webpack.prod.config.js

@@ -0,0 +1,136 @@
+const path = require('path');
+const webpack = require('webpack');
+const {merge} = require("webpack-merge");
+
+let config = {
+    optimization: {
+        minimize: true,
+    },
+    // Path to your entry point. From this file Webpack will begin his work
+    // entry: ["babel-polyfill", path.resolve(__dirname, entrypoint)],
+    resolve: {
+        // Add '.ts' and '.tsx' as resolvable extensions.
+        extensions: [".webpack.js", ".web.js", ".ts", ".tsx", ".js", ".wasm", "..."],
+        fallback: {
+            "fs": false,
+            "tls": false,
+            "net": false,
+            "path": require.resolve("path-browserify"),
+            "zlib": false,
+            "http": false,
+            "https": false,
+            "stream": require.resolve("stream-browserify"),
+            "buffer": require.resolve("buffer"),
+            "crypto": require.resolve("crypto-browserify"),
+            "crypto-browserify": require.resolve("crypto-browserify"),
+            "async_hooks": false,
+            'process/browser': require.resolve('process/browser'),
+            "util": require.resolve("util/"),
+            "url": require.resolve("url/")
+        }
+    },
+    module: {
+        rules: [
+            // All files with a '.ts' or '.tsx' extension will be handled by 'ts-loader'.
+            {
+                test: /\.tsx?$/,
+                loader: "ts-loader",
+                exclude: ["/node_modules/", /\.d\.ts$/iu]
+            },
+            {
+                test: /\.d\.ts$/,
+                loader: 'ignore-loader'
+            },
+            // All output '.js' files will have any sourcemaps re-processed by 'source-map-loader'.
+            {
+                test: /\.js$/,
+                use: [
+                    "source-map-loader",
+                    {
+                        loader: "babel-loader",
+                        options: {
+                            presets: ["@babel/preset-env"],
+                            sourceMaps: true
+                        }
+                    }
+                ],
+                exclude: /(node_modules)/
+            },
+            {
+                test: /\.mjs$/,
+                exclude: /(node_modules)/,
+                type: "javascript/auto"
+            },
+            {
+                test: /\.wasm$/,
+                type: "asset/inline",
+            },
+        ],
+        parser: {
+            javascript: {
+                dynamicImportMode: 'eager'
+            }
+        }
+    },
+    plugins: [
+        // Work around for Buffer is undefined:
+        // https://github.com/webpack/changelog-v5/issues/10
+        new webpack.ProvidePlugin({
+            Buffer: ["buffer", "Buffer"]
+        }),
+        new webpack.ProvidePlugin({
+            process: "process/browser"
+        })
+    ],
+    // ignoreWarnings: [/Failed to parse source map/],
+    experiments: {
+        asyncWebAssembly: true,
+        topLevelAwait: true,
+        syncWebAssembly: true,
+        // futureDefaults: true,
+    },
+    mode: "production",
+    devtool: "source-map"
+};
+
+let nodeConfigs = merge(config, {
+    output: {
+        path: path.resolve(__dirname, "./dist/server"),
+        filename: "index.js"
+    },
+    resolve: {
+        fallback: {}
+    },
+    target: "node",
+    entry: ["babel-polyfill", path.resolve(__dirname, "./index.node.ts")],
+    externals: [
+        {
+            'utf-8-validate': 'commonjs utf-8-validate',
+            'bufferutil': 'commonjs bufferutil',
+        },
+    ],
+});
+let webConfigs = merge(config, {
+    output: {
+        path: path.resolve(__dirname, "./dist/browser/"),
+        filename: "index.js"
+    },
+    plugins: [
+        // new CopyPlugin({
+        //     patterns: [{
+        //         from: "./dist/browser/saito.js",
+        //         to: "../../public/javascripts/saito.js",
+        //     }]
+        // })
+    ],
+    resolve: {
+        fallback: {
+            "bufferutil": false,
+            "utf-8-validate": false
+        }
+    },
+    target: "web",
+    entry: ["babel-polyfill", path.resolve(__dirname, "./index.web.ts")],
+});
+
+module.exports = [nodeConfigs, webConfigs];

package/lib/custom/shared_methods.custom.ts

@@ -1,72 +0,0 @@
-import SharedMethods from "../../shared_methods";
-import Saito from "../../saito";
-
-export default class CustomSharedMethods implements SharedMethods {
-    processApiCall(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): Promise<void> {
-        throw new Error("Method not implemented.");
-    }
-
-    connectToPeer(peerData: any): void {
-        throw new Error("Method not implemented.");
-    }
-
-    disconnectFromPeer(peerIndex: bigint): void {
-        throw new Error("Method not implemented.");
-    }
-
-    fetchBlockFromPeer(url: string): Promise<Uint8Array> {
-        throw new Error("Method not implemented.");
-    }
-
-    isExistingFile(key: string): boolean {
-        throw new Error("Method not implemented.");
-    }
-
-    loadBlockFileList(): Array<string> {
-        throw new Error("Method not implemented.");
-    }
-
-
-    processApiError(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): void {
-        let promise = Saito.getInstance().promises.get(msgIndex);
-        if (promise) {
-            promise.reject(buffer);
-        } else {
-            console.error("callback not found for callback index : " + msgIndex + " from peer : " + peerIndex);
-        }
-    }
-
-    processApiSuccess(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): void {
-        let promise = Saito.getInstance().promises.get(msgIndex);
-        if (promise) {
-            promise.resolve(buffer);
-        } else {
-            console.error("callback not found for callback index : " + msgIndex + " from peer : " + peerIndex);
-        }
-    }
-
-    readValue(key: string): Uint8Array | null {
-        throw new Error("Method not implemented.");
-    }
-
-    removeValue(key: string): void {
-        throw new Error("Method not implemented.");
-    }
-
-    sendMessage(peerIndex: bigint, buffer: Uint8Array): void {
-        throw new Error("Method not implemented.");
-    }
-
-    sendMessageToAll(buffer: Uint8Array, exceptions: Array<bigint>): void {
-        throw new Error("Method not implemented.");
-    }
-
-    writeValue(key: string, value: Uint8Array): void {
-        throw new Error("Method not implemented.");
-    }
-
-    sendInterfaceEvent(event: String, peerIndex: bigint): void {
-        throw new Error("Method not implemented.");
-    }
-
-}