saito-js 0.0.2

package/lib/transaction.ts

@@ -0,0 +1,173 @@
+import type {WasmTransaction} from 'saito-wasm/dist/types/pkg/node/index_bg';
+import Slip from "./slip";
+import Saito from "../saito";
+import Factory from "./factory";
+
+export enum TransactionType {
+    Normal = 0,
+    Fee = 1,
+    GoldenTicket = 2,
+    ATR = 3,
+    Vip = 4,
+    SPV = 5,
+    Issuance = 6,
+    Other = 7,
+}
+
+export default class Transaction {
+    protected tx: WasmTransaction;
+    public static Type: any;
+    public msg: any = {};
+
+    // TODO : factory pattern might be useful here to remove unnecessary wrappings
+    constructor(tx?: WasmTransaction, json?: any) {
+        if (tx) {
+            this.tx = tx;
+        } else {
+            this.tx = new Transaction.Type();
+        }
+        if (json) {
+            for (let slip of json.to) {
+                let s = new Slip(undefined, slip);
+                this.addToSlip(s);
+            }
+            for (let slip of json.from) {
+                let s = new Slip(undefined, slip);
+                this.addFromSlip(s);
+            }
+            this.timestamp = json.timestamp;
+            this.type = json.type;
+            this.signature = json.signature;
+            this.data = new Uint8Array(Buffer.from(json.buffer, "base64"));
+            this.txs_replacements = json.txs_replacements;
+        }
+    }
+
+    public get wasmTransaction(): WasmTransaction {
+        return this.tx;
+    }
+
+    public addFromSlip(slip: Slip) {
+        this.tx.add_from_slip(slip.wasmSlip);
+    }
+
+    public addToSlip(slip: Slip) {
+        this.tx.add_to_slip(slip.wasmSlip);
+    }
+
+    public get to(): Array<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 Saito.getInstance().factory.createSlip(slip);
+        });
+    }
+
+    public get type(): TransactionType {
+        return this.tx.type as TransactionType;
+    }
+
+    public set type(type: TransactionType) {
+        this.tx.type = type as number;
+    }
+
+    public get timestamp(): number {
+        return Number(this.tx.timestamp);
+    }
+
+    public set timestamp(timestamp: bigint | number) {
+        this.tx.timestamp = BigInt(timestamp);
+    }
+
+    public set signature(sig: string) {
+        this.tx.signature = sig;
+    }
+
+    public get signature(): string {
+        return this.tx.signature;
+    }
+
+    public set data(buffer: Uint8Array) {
+        this.tx.data = buffer;
+    }
+
+    public get data(): Uint8Array {
+        return this.tx.data;
+    }
+
+    public set txs_replacements(r: number) {
+        this.tx.txs_replacements = r;
+    }
+
+    public get txs_replacements(): number {
+        return this.tx.txs_replacements;
+    }
+
+    public get total_fees(): bigint {
+        return this.tx.total_fees;
+    }
+
+    public sign() {
+        Saito.getInstance().signTransaction(this);
+    }
+
+    public isFrom(key: string): boolean {
+        return this.tx.is_from(key);
+    }
+
+    public isTo(key: string): boolean {
+        return this.tx.is_to(key);
+    }
+
+    public toJson() {
+        this.packData();
+        return {
+            to: this.to.map((slip) => slip.toJson()),
+            from: this.from.map((slip) => slip.toJson()),
+            type: this.type,
+            timestamp: this.timestamp,
+            signature: this.signature,
+            buffer: Buffer.from(this.data).toString("base64"),
+            txs_replacements: this.txs_replacements,
+            total_fees: this.total_fees,
+        };
+    }
+
+    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);
+            return null;
+        }
+    }
+
+    public packData() {
+        if (Object.keys(this.msg).length === 0) {
+            this.data = new Uint8Array(Buffer.alloc(0));
+        } else {
+            this.data = new Uint8Array(Buffer.from(JSON.stringify(this.msg), "utf-8"));
+        }
+    }
+
+    public unpackData() {
+        if (this.data.byteLength === 0) {
+            this.msg = {};
+        } else {
+            try {
+                this.msg = JSON.parse(Buffer.from(this.data).toString("utf-8"));
+            } catch (error) {
+                console.log("failed parsing tx buffer into msg");
+                console.error(error);
+                this.msg = {};
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "saito-js",
+  "version": "0.0.2",
+  "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": "webpack",
+    "serve": "webpack-dev-server"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.16.5",
+    "@babel/preset-env": "^7.16.5",
+    "@babel/preset-typescript": "^7.16.5",
+    "@types/jest": "^29.2.5",
+    "@types/ws": "^8.5.4",
+    "@wasm-tool/wasm-pack-plugin": "1.6.0",
+    "babel-loader": "^8.2.3",
+    "babel-polyfill": "^6.26.0",
+    "copy-webpack-plugin": "^11.0.0",
+    "crypto-browserify": "^3.12.0",
+    "html-webpack-plugin": "^5.5.0",
+    "ignore-loader": "^0.1.2",
+    "path-browserify": "^1.0.1",
+    "source-map-loader": "^3.0.0",
+    "stream-browserify": "^3.0.0",
+    "ts-loader": "^9.4.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^4.9.4",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1",
+    "webpack-merge": "^5.8.0"
+  },
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "cookie-parser": "~1.4.6",
+    "cors": "^2.8.5",
+    "debug": "~4.3.4",
+    "express": "~4.18.2",
+    "morgan": "~1.10.0",
+    "node-fetch": "^2.6.1",
+    "process": "^0.11.10",
+    "url": "^0.11.0",
+    "util": "^0.12.5",
+    "ws": "^8.12.0"
+  }
+}

package/saito.ts

@@ -0,0 +1,322 @@
+import SharedMethods from "./shared_methods";
+import Transaction from "./lib/transaction";
+import Block from "./lib/block";
+import Factory from "./lib/factory";
+import Peer from "./lib/peer";
+
+// export enum MessageType {
+//     HandshakeChallenge = 1,
+//     HandshakeResponse,
+//     //HandshakeCompletion,
+//     ApplicationMessage = 4,
+//     Block,
+//     Transaction,
+//     BlockchainRequest,
+//     BlockHeaderHash,
+//     Ping,
+//     SPVChain,
+//     Services,
+//     GhostChain,
+//     GhostChainRequest,
+//     Result,
+//     Error,
+//     ApplicationTransaction,
+// }
+
+export default class Saito {
+    private static instance: Saito;
+    private static libInstance: any;
+    sockets: Map<bigint, any> = new Map<bigint, any>();
+    nextIndex: bigint = BigInt(0);
+    factory = new Factory();
+    promises = new Map<number, any>();
+    private callbackIndex: number = 1;
+
+
+    public static async initialize(configs: any, sharedMethods: SharedMethods, factory = new Factory()) {
+        this.instance = new Saito(factory);
+
+        // @ts-ignore
+        globalThis.shared_methods = {
+            send_message: (peer_index: bigint, buffer: Uint8Array) => {
+                sharedMethods.sendMessage(peer_index, buffer);
+            },
+            send_message_to_all: (buffer: Uint8Array, exceptions: Array<bigint>) => {
+                sharedMethods.sendMessageToAll(buffer, exceptions);
+            },
+            connect_to_peer: (peer_data: any) => {
+                sharedMethods.connectToPeer(peer_data);
+            },
+            write_value: (key: string, value: Uint8Array) => {
+                return sharedMethods.writeValue(key, value);
+            },
+            read_value: (key: string) => {
+                return sharedMethods.readValue(key);
+            },
+            load_block_file_list: () => {
+                return sharedMethods.loadBlockFileList();
+            },
+            is_existing_file: (key: string) => {
+                return sharedMethods.isExistingFile(key);
+            },
+            remove_value: (key: string) => {
+                return sharedMethods.removeValue(key);
+            },
+            disconnect_from_peer: (peer_index: bigint) => {
+                return sharedMethods.disconnectFromPeer(peer_index);
+            },
+            fetch_block_from_peer: (hash: Uint8Array, peer_index: bigint, url: string) => {
+                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) => {
+                return sharedMethods.processApiSuccess(buffer, msgIndex, peerIndex);
+            },
+            process_api_error: (buffer: Uint8Array, msgIndex: number, peerIndex: bigint) => {
+                return sharedMethods.processApiError(buffer, msgIndex, peerIndex);
+            },
+            send_interface_event: (event: string, peerIndex: bigint) => {
+                return sharedMethods.sendInterfaceEvent(event, peerIndex);
+            }
+        };
+
+        await Saito.getLibInstance().initialize(JSON.stringify(configs));
+
+        console.log("saito initialized");
+
+        setInterval(() => {
+            Saito.getLibInstance().process_timer_event(BigInt(100));
+            // console.log(`WASM memory usage is ${wasm.memory.buffer.byteLength} bytes`);
+        }, 100);
+    }
+
+    constructor(factory: Factory) {
+        this.factory = factory;
+    }
+
+    public static getInstance(): Saito {
+        return Saito.instance;
+    }
+
+    public static getLibInstance(): any {
+        return Saito.libInstance;
+    }
+
+    public static setLibInstance(instance: any) {
+        Saito.libInstance = instance;
+    }
+
+    public addNewSocket(socket: any): bigint {
+        this.nextIndex++;
+        this.sockets.set(this.nextIndex, socket);
+        return this.nextIndex;
+    }
+
+    public getSocket(index: bigint): any | null {
+        return this.sockets.get(index);
+    }
+
+    public removeSocket(index: bigint) {
+        let socket = this.sockets.get(index);
+        this.sockets.delete(index);
+        socket.close();
+    }
+
+    public async initialize(configs: any): Promise<any> {
+        return Saito.getLibInstance().initialize(configs);
+    }
+
+    public async getLatestBlockHash(): Promise<string> {
+        return Saito.getLibInstance().get_latest_block_hash();
+    }
+
+    public async getBlock<B extends Block>(blockHash: string): Promise<B> {
+        let block = await Saito.getLibInstance().get_block(blockHash);
+        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 processNewPeer(index: bigint, peer_config: any): Promise<void> {
+        return Saito.getLibInstance().process_new_peer(index, peer_config);
+    }
+
+    public async processPeerDisconnection(peer_index: bigint): Promise<void> {
+        return Saito.getLibInstance().process_peer_disconnection(peer_index);
+    }
+
+    public async processMsgBufferFromPeer(buffer: Uint8Array, peer_index: bigint): Promise<void> {
+        return Saito.getLibInstance().process_msg_buffer_from_peer(buffer, peer_index);
+    }
+
+    public async processFetchedBlock(buffer: Uint8Array, hash: Uint8Array, peer_index: bigint): Promise<void> {
+        return Saito.getLibInstance().process_fetched_block(buffer, hash, peer_index);
+    }
+
+    public async processTimerEvent(duration_in_ms: bigint): Promise<void> {
+        return Saito.getLibInstance().process_timer_event(duration_in_ms);
+    }
+
+    public hash(buffer: Uint8Array): string {
+        return Saito.getLibInstance().hash(buffer);
+    }
+
+    public signBuffer(buffer: Uint8Array, privateKey: String): string {
+        return Saito.getLibInstance().sign_buffer(buffer, privateKey);
+    }
+
+    public verifySignature(buffer: Uint8Array, signature: string, publicKey: string): boolean {
+        return Saito.getLibInstance().verify_signature(buffer, signature, publicKey);
+    }
+
+    public async createTransaction<T extends Transaction>(
+        publickey = "",
+        amount = BigInt(0),
+        fee = BigInt(0),
+        force_merge = false
+    ): Promise<T> {
+        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 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 getBalance(): Promise<bigint> {
+        return Saito.getLibInstance().get_balance();
+    }
+
+    public async getPeers(): Promise<Array<Peer>> {
+        let peers = await Saito.getLibInstance().get_peers();
+        return peers.map((peer: any) => {
+            return this.factory.createPeer(peer);
+        });
+    }
+
+
+    public async getPeer(index: bigint): Promise<Peer | null> {
+        let peer = await Saito.getLibInstance().get_peer(index);
+        if (!peer) {
+            return null;
+        }
+        return this.factory.createPeer(peer);
+    }
+
+    public generatePrivateKey(): string {
+        return Saito.getLibInstance().generate_private_key();
+    }
+
+    public generatePublicKey(privateKey: string): string {
+        return Saito.getLibInstance().generate_public_key(privateKey);
+    }
+
+    public async propagateTransaction(tx: Transaction) {
+        return Saito.getLibInstance().propagate_transaction(tx.wasmTransaction);
+    }
+
+    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
+                });
+                Saito.getLibInstance().send_api_call(buffer, callbackIndex, peerIndex);
+            });
+        } else {
+            return Saito.getLibInstance().send_api_call(buffer, callbackIndex, peerIndex);
+        }
+    }
+
+    public async sendApiSuccess(msgId: number, buffer: Uint8Array, peerIndex: bigint) {
+        await Saito.getLibInstance().send_api_success(buffer, msgId, peerIndex);
+    }
+
+    public async sendApiError(msgId: number, buffer: Uint8Array, peerIndex: bigint) {
+        await Saito.getLibInstance().send_api_error(buffer, msgId, peerIndex);
+    }
+
+    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);
+        let buffer = transaction.wasmTransaction.serialize();
+        console.log("sendTransactionWithCallback : " + peerIndex + " with length : " + buffer.byteLength + " sent : ", transaction.msg);
+        await this.sendApiCall(buffer, peerIndex || BigInt(0), !!callback)
+            .then((buffer: Uint8Array) => {
+                if (callback) {
+                    // console.log("deserializing tx. buffer length = " + buffer.byteLength);
+                    console.log("sendTransactionWithCallback. buffer length = " + buffer.byteLength);
+
+                    let tx = this.factory.createTransaction();
+                    tx.data = buffer;
+                    tx.unpackData();
+                    // let tx = Transaction.deserialize(buffer, this.factory);
+                    // if (tx) {
+                    //     console.log("sendTransactionWithCallback received : ", tx);
+                    //     return callback(tx.data);
+                    // } else {
+                    //     console.log("sendTransactionWithCallback sending direct buffer since tx deserialization failed");
+                    return callback(tx);
+                    // }
+                }
+            })
+            .catch((error) => {
+                console.error(error);
+                if (callback) {
+                    return callback({err: error.toString()});
+                }
+            });
+    }
+
+    public async propagateServices(peerIndex: bigint, services: string[]) {
+        return Saito.getLibInstance().propagateServices(peerIndex, services);
+    }
+
+    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 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);
+    }
+}
+

package/shared_methods.ts

@@ -0,0 +1,30 @@
+export default interface SharedMethods {
+    sendMessage(peerIndex: bigint, buffer: Uint8Array): void;
+
+    sendMessageToAll(buffer: Uint8Array, exceptions: Array<bigint>): void;
+
+    connectToPeer(peerData: any): void;
+
+    writeValue(key: string, value: Uint8Array): void;
+
+    readValue(key: string): Uint8Array | null;
+
+    loadBlockFileList(): Array<string>;
+
+    isExistingFile(key: string): boolean;
+
+    removeValue(key: string): void;
+
+    disconnectFromPeer(peerIndex: bigint): void;
+
+    fetchBlockFromPeer(url: string): Promise<Uint8Array>;
+
+    processApiCall(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): Promise<void>;
+
+    processApiSuccess(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): void;
+
+    processApiError(buffer: Uint8Array, msgIndex: number, peerIndex: bigint): void;
+
+    sendInterfaceEvent(event: String, peerIndex: bigint): void;
+
+}

package/tests/index.test.ts

@@ -0,0 +1,35 @@
+// // @ts-ignore
+// import {expect} from "chai";
+// import SaitoJs from "../index";
+//
+//
+// describe('setup test', function () {
+//     it('should load the wasm lib correctly', async function () {
+//         console.log("loading...");
+//
+//         // // @ts-ignore
+//         // const s = await import("saito-wasm/dist/server");
+//         // // @ts-ignore
+//         //
+//         // console.log("s = ", s);
+//         // // @ts-ignore
+//         // let s1 = await s;
+//         // console.log("s1 = ", s1);
+//         // // @ts-ignore
+//         // let saito = s1.default;
+//         // // console.log("s2 = ", saito);
+//         //
+//         // expect(saito).to.exist;
+//         // // let s = await saito.default;
+//         // // console.log(s);
+//         // console.log("lib test 2 = ", saito);
+//         let result = await SaitoJs.initialize();
+//         expect(result).to.equal("initialized");
+//
+//         let saito = SaitoJs.getInstance();
+//
+//         expect(saito).to.exist;
+//         expect(saito.get_public_key).to.exist;
+//         expect(saito.get_public_key()).to.equal("publickey");
+//     });
+// });