saito-js 0.0.2

package/babel.config.json

@@ -0,0 +1,13 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": "current"
+        }
+      }
+    ],
+    "@babel/preset-typescript"
+  ]
+}

package/configs.ts

@@ -0,0 +1,26 @@
+type Configs = {
+    server: {
+        host: string,
+        port: number,
+        protocol: string,
+        endpoint: {
+            host: string,
+            port: number,
+            protocol: string,
+        },
+        verification_threads: number,
+        channel_size: number,
+        stat_timer_in_ms: number,
+        reconnection_wait_time: number,
+        thread_sleep_time_in_ms: number,
+        block_fetch_batch_size: number,
+    },
+    peers: {
+        host: string,
+        port: number,
+        protocol: string,
+        synctype: string
+    }[]
+};
+
+export default Configs;

package/index.node.ts

@@ -0,0 +1,40 @@
+import Saito from './saito';
+import SharedMethods from "./shared_methods";
+import Configs from "./configs";
+import Transaction from "./lib/transaction";
+import Slip from "./lib/slip";
+import Block from "./lib/block";
+import Peer from "./lib/peer";
+import Factory from "./lib/factory";
+
+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 default Saito;

package/index.web.ts

@@ -0,0 +1,41 @@
+import Saito from './saito';
+import SharedMethods from "./shared_methods";
+import Configs from "./configs";
+import Transaction from "./lib/transaction";
+import Slip from "./lib/slip";
+import Block from "./lib/block";
+import Peer from "./lib/peer";
+import Factory from "./lib/factory";
+
+/**
+ *
+ * @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");
+
+    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);
+                });
+        });
+}
+
+
+export default Saito;

package/lib/block.ts

@@ -0,0 +1,42 @@
+import type {WasmBlock} from 'saito-wasm/dist/types/pkg/node/index_bg';
+import Transaction from "./transaction";
+import Saito from "../saito";
+
+export enum BlockType {
+    Ghost = 0,
+    Header = 1,
+    Pruned = 2,
+    Full = 3,
+}
+
+
+export default class Block {
+    protected block: WasmBlock;
+    public static Type: any;
+
+    constructor(block?: WasmBlock) {
+        if (block) {
+            this.block = block;
+        } else {
+            this.block = Block.Type();
+        }
+    }
+
+    public get transactions(): Array<Transaction> {
+        return this.block.transactions.map(tx => {
+            return Saito.getInstance().factory.createTransaction(tx);
+        });
+    }
+
+    public get id(): bigint {
+        return this.block.id;
+    }
+
+    public get hash(): string {
+        return this.block.hash;
+    }
+
+    public serialize(): Uint8Array {
+        return this.block.serialize();
+    }
+}

package/lib/custom/shared_methods.custom.ts

@@ -0,0 +1,72 @@
+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.");
+    }
+
+}

package/lib/custom/shared_methods.web.ts

@@ -0,0 +1,122 @@
+import Saito from "../../saito";
+import CustomSharedMethods from "./shared_methods.custom";
+
+export default class WebSharedMethods extends CustomSharedMethods {
+    connectToPeer(peerData: any): void {
+        let protocol = "ws";
+        if (peerData.protocol === "https") {
+            protocol = "wss";
+        }
+        let url = protocol + "://" + peerData.host + ":" + peerData.port + "/wsopen";
+
+        try {
+            console.log("connecting to " + url + "....");
+            let socket = new WebSocket(url);
+            socket.binaryType = "arraybuffer";
+            let index = Saito.getInstance().addNewSocket(socket);
+
+            socket.onmessage = (event: MessageEvent) => {
+                // console.log("buffer : ", event.data);
+                Saito.getLibInstance().process_msg_buffer_from_peer(new Uint8Array(event.data), index);
+            };
+
+            socket.onopen = () => {
+                Saito.getLibInstance().process_new_peer(index, peerData);
+            };
+            socket.onclose = () => {
+                Saito.getLibInstance().process_peer_disconnection(index);
+            };
+
+            console.log("connected to : " + url + " with peer index : " + index);
+        } catch (e) {
+            console.error(e);
+        }
+    }
+
+    disconnectFromPeer(peerIndex: bigint): void {
+        Saito.getInstance().removeSocket(peerIndex);
+    }
+
+    fetchBlockFromPeer(url: string): Promise<Uint8Array> {
+        return fetch(url)
+            .then((res: any) => {
+                return res.arrayBuffer();
+            })
+            .then((buffer: ArrayBuffer) => {
+                return new Uint8Array(buffer);
+            });
+    }
+
+    isExistingFile(key: string): boolean {
+        try {
+            return !!localStorage.getItem(key);
+        } catch (error) {
+            console.error(error);
+            return false;
+        }
+    }
+
+    loadBlockFileList(): Array<string> {
+        try {
+            // console.log("loading block file list...");
+            // let files = Object.keys(localStorage);
+            // console.log("files : ", files);
+            // return files;
+            return [];
+        } catch (e) {
+            console.error(e);
+            return [];
+        }
+    }
+
+    readValue(key: string): Uint8Array | null {
+        try {
+            let data = localStorage.getItem(key);
+            if (!data) {
+                console.log("item not found for key : " + key);
+                return null;
+            }
+            let buffer = Buffer.from(data, "base64");
+            return new Uint8Array(buffer);
+        } catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+
+    removeValue(key: string): void {
+        try {
+            localStorage.removeItem(key);
+        } catch (e) {
+            console.error(e);
+        }
+    }
+
+    sendMessage(peerIndex: bigint, buffer: Uint8Array): void {
+        console.debug("sending message to peer : " + peerIndex);
+        let socket = Saito.getInstance().getSocket(peerIndex);
+        socket.send(buffer);
+    }
+
+    sendMessageToAll(buffer: Uint8Array, exceptions: Array<bigint>): void {
+        console.debug("sending message to  all");
+        Saito.getInstance().sockets.forEach((socket, key) => {
+            if (exceptions.includes(key)) {
+                return;
+            }
+            socket.send(buffer);
+        });
+    }
+
+    writeValue(key: string, value: Uint8Array): void {
+        try {
+            localStorage.setItem(key, Buffer.from(value).toString("base64"));
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    sendInterfaceEvent(event: String, peerIndex: bigint) {
+        throw new Error("Method not implemented.");
+    }
+}

package/lib/factory.ts

@@ -0,0 +1,25 @@
+import Block from "./block";
+import Transaction from "./transaction";
+import Slip from "./slip";
+import Peer from "./peer";
+
+export default class Factory {
+    constructor() {
+    }
+
+    public createBlock(data?: any): Block {
+        return new Block(data);
+    }
+
+    public createTransaction<T extends Transaction>(data?: any): Transaction {
+        return new Transaction(data);
+    }
+
+    public createSlip(data?: any): Slip {
+        return new Slip(data);
+    }
+
+    public createPeer(data?: any): Peer {
+        return new Peer(data);
+    }
+}

package/lib/peer.ts

@@ -0,0 +1,50 @@
+import type {WasmPeer} from "saito-wasm/dist/types/pkg/node/index_bg";
+
+export default class Peer {
+    protected peer: WasmPeer;
+    public static Type: any;
+
+    constructor(peer?: WasmPeer, peerIndex?: bigint) {
+        if (peer) {
+            this.peer = peer;
+        } else {
+            this.peer = new Peer.Type(peerIndex);
+        }
+    }
+
+    public get publicKey(): string {
+        return this.peer.public_key;
+    }
+
+    // public set publicKey(key: string) {
+    //     this.peer.public_key = key;
+    // }
+
+    public get keyList(): Array<string> {
+        return this.peer.key_list;
+    }
+
+    public get peerIndex(): bigint {
+        return this.peer.peer_index;
+    }
+
+    public get synctype(): string {
+        return this.peer.sync_type;
+    }
+
+    public get services(): string[] {
+        return this.peer.services;
+    }
+
+    public set services(s: string[]) {
+        this.peer.services = s;
+    }
+
+    public hasService(service: string): boolean {
+        return this.peer.has_service(service);
+    }
+
+    public isMainPeer(): boolean {
+        return this.peer.is_main_peer();
+    }
+}

package/lib/saito_factory.ts

@@ -0,0 +1,18 @@
+// import Factory from "./factory";
+// import Block from "./block";
+// import Transaction from "./transaction";
+// import Slip from "./slip";
+//
+// export default class SaitoFactory extends Factory {
+//     public createBlock(data: any): Block {
+//         return new Block(data);
+//     }
+//
+//     public createTransaction(data: any): Transaction {
+//         return new Transaction(data);
+//     }
+//
+//     public createSlip(data: any): Slip {
+//         return new Slip(data);
+//     }
+// }

package/lib/slip.ts

@@ -0,0 +1,119 @@
+import type {WasmSlip} from 'saito-wasm/dist/types/pkg/node/index_bg';
+
+export enum SlipType {
+    Normal = 0,
+    ATR = 1,
+    VipInput = 2,
+    VipOutput = 3,
+    MinerInput = 4,
+    MinerOutput = 5,
+    RouterInput = 6,
+    RouterOutput = 7,
+    Other = 8,
+}
+
+export default class Slip {
+    private slip: WasmSlip;
+    public static Type: any;
+
+    public constructor(slip?: WasmSlip, json?: any) {
+        if (!slip) {
+            this.slip = new Slip.Type();
+        } else {
+            this.slip = slip;
+        }
+        if (json) {
+            this.publicKey = json.publicKey;
+            this.type = json.type;
+            this.amount = json.amount;
+            this.index = json.index;
+            this.blockId = json.blockId;
+            this.txOrdinal = json.txOrdinal;
+            this.utxoKey = json.utxoKey;
+        }
+    }
+
+    public get wasmSlip(): WasmSlip {
+        return this.slip;
+    }
+
+    public get type(): SlipType {
+        return this.slip.slip_type as SlipType;
+    }
+
+    public set type(type: SlipType) {
+        this.slip.slip_type = type as number;
+    }
+
+    public get amount(): bigint {
+        return this.slip.amount;
+    }
+
+    public set amount(amount: bigint) {
+        this.slip.amount = amount;
+    }
+
+    public get publicKey(): string {
+        return this.slip.public_key;
+    }
+
+    public set publicKey(key: string) {
+        this.slip.public_key = key;
+    }
+
+    public set index(index: number) {
+        this.slip.slip_index = index;
+    }
+
+    public get index(): number {
+        return this.slip.slip_index;
+    }
+
+    public set blockId(id: bigint) {
+        this.slip.block_id = id;
+    }
+
+    public get blockId(): bigint {
+        return this.slip.block_id;
+    }
+
+    public set txOrdinal(ordinal: bigint) {
+        this.slip.tx_ordinal = ordinal;
+    }
+
+    public get txOrdinal(): bigint {
+        return this.slip.tx_ordinal;
+    }
+
+    public set utxoKey(key: string) {
+        this.slip.utxo_key = key;
+    }
+
+    public get utxoKey(): string {
+        return this.slip.utxo_key;
+    }
+
+    public toJson(): {
+        blockId: bigint;
+        utxoKey: string;
+        amount: bigint;
+        index: number;
+        publicKey: string;
+        txOrdinal: bigint;
+        type: any;
+    } {
+        return {
+            publicKey: this.publicKey,
+            type: this.type,
+            amount: this.amount,
+            index: this.index,
+            blockId: this.blockId,
+            txOrdinal: this.txOrdinal,
+            utxoKey: this.utxoKey,
+        };
+    }
+
+    public clone() {
+        return new Slip(undefined, this.toJson());
+    }
+}