saito-js 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saito-js",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "js wrappings around saito-core using wasm",
   "scripts": {
     "test": "env TS_NODE_PROJECT=\"tsconfig.testing.json\" mocha --require ts-node/register 'tests/**/*.ts'",

package/.github/workflows/publish.yml

@@ -1,50 +0,0 @@
-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: build
-        if: ${{ env.latest_version != env.current_version }}
-        run: npm run build
-
-      - 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

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

package/babel.config.json

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

package/configs.ts

@@ -1,26 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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";
-import Wallet from "./lib/wallet";
-import Blockchain from "./lib/blockchain";
-
-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,
-  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,47 +0,0 @@
-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";
-import Wallet from "./lib/wallet";
-import Blockchain from "./lib/blockchain";
-
-/**
- *
- * @param configs
- * @param sharedMethods
- */
-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;
-        Wallet.Type = s.WasmWallet;
-        Blockchain.Type = s.WasmBlockchain;
-        return Saito.initialize(configs, sharedMethods, factory, privateKey);
-      });
-    });
-}
-
-export default Saito;

package/lib/block.ts

@@ -1,42 +0,0 @@
-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/blockchain.ts

@@ -1,14 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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,123 +0,0 @@
-import Saito from "../../saito";
-
-import CustomSharedMethods from "./custom_shared_methods";
-
-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

@@ -1,32 +0,0 @@
-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() {}
-
-  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);
-  }
-  public createWallet(data: any): Wallet {
-    return new Wallet(data);
-  }
-  public createBlockchain(data: any): Blockchain {
-    return new Blockchain(data);
-  }
-}

package/lib/peer.ts

@@ -1,50 +0,0 @@
-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

@@ -1,18 +0,0 @@
-// 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

@@ -1,119 +0,0 @@
-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 | number) {
-        this.slip.amount = BigInt(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());
-    }
-}