chain-db-ts 0.0.1

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { ChainDB, connect } from './features/chain-db';
+export { Access } from './features/access';
+export { BasicResponse, SignedUserAccount } from './features/types';

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+exports.__esModule = true;
+exports.Access = exports.connect = exports.ChainDB = void 0;
+var chain_db_1 = require("./features/chain-db");
+__createBinding(exports, chain_db_1, "ChainDB");
+__createBinding(exports, chain_db_1, "connect");
+var access_1 = require("./features/access");
+__createBinding(exports, access_1, "Access");

package/features/access.d.ts

@@ -0,0 +1,6 @@
+export declare class Access {
+    user: string;
+    password: string;
+    constructor(user: string, password: string);
+    parse: (data_base: string, table_name: string) => string;
+}

package/features/access.js

@@ -0,0 +1,16 @@
+import sha256 from 'sha256';
+var Access = /** @class */ (function () {
+    function Access(user, password) {
+        var _this = this;
+        this.user = '';
+        this.password = '';
+        this.parse = function (data_base, table_name) {
+            var access_info = "".concat(data_base).concat(table_name).concat(_this.user).concat(_this.password);
+            return sha256(access_info);
+        };
+        this.user = user;
+        this.password = password;
+    }
+    return Access;
+}());
+export { Access };

package/features/chain-db.d.ts

@@ -0,0 +1,74 @@
+import { Access } from './access';
+import { BasicResponse, SignedUserAccount, TransferUnitsRegistry } from './types';
+export declare class ChainDB {
+    api: string;
+    name: string;
+    access: Access | null;
+    access_key: string;
+    /**
+     * Connection information.
+     * @param server Server location. If the `server` parameter is empty, then "http://localhost" will be used.
+     * @param data_base Data base name
+     * @param user  User to access the data base
+     * @param password  Password to access the data base
+     */
+    connect(server: string | null, data_base: string, user: string, password: string): void;
+    /**
+     * Create a new user account inside the connected table
+     * @param user_name
+     * @param password
+     * @param units
+     * @param password_hint
+     * @returns
+     */
+    create_user_account(user_name: string, password: string, units?: number, password_hint?: string): Promise<BasicResponse<SignedUserAccount>>;
+    /**
+     * Get user account info (login method)
+     * @param user_name
+     * @param password
+     * @returns
+     */
+    get_user_account(user_name: string, password: string): Promise<BasicResponse<SignedUserAccount>>;
+    /**
+     * Get user account info by its id
+     * @param user_id
+     * @returns
+     */
+    get_user_account_by_id(user_id: string): Promise<BasicResponse<SignedUserAccount>>;
+    /**
+     * Check if user_name is already taken
+     * @param user_name
+     */
+    check_user_name(user_name: string): Promise<BasicResponse<string>>;
+    /**
+     * Transfer units between users
+     * @param from user_id
+     * @param to user_id
+     * @param units
+     * @returns
+     */
+    transfer_units(from: string, to: string, units: number): Promise<BasicResponse<null>>;
+    /**
+     * Fetch the last Transference of units Records by User
+     * @param user_id
+     * @returns
+     */
+    get_transfer_by_user_id(user_id: string): Promise<BasicResponse<TransferUnitsRegistry>>;
+    /**
+     * Fetch all Transference of units Records by User
+     * @param user_id
+     * @returns
+     */
+    get_all_transfers_by_user_id(user_id: string): Promise<BasicResponse<TransferUnitsRegistry[]>>;
+    /**
+     * Initialize a table, fetching its more updated data
+     */
+    get_table<Model>(table_name: string, model: Model): Promise<{
+        table: Model;
+        /**
+         * Persist table data on chain
+         */
+        persist: () => Promise<void>;
+    }>;
+}
+export declare const connect: (server: string | null, data_base: string, user: string, password: string) => ChainDB;

package/features/chain-db.js

@@ -0,0 +1,317 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import sha256 from 'sha256';
+import axios from 'axios';
+import { Access } from './access';
+import { API, CHECK_USER_NAME, CREATE_USER_ACCOUNT, GET_ALL_TRANSFER_BY_USER_ID, GET_TRANSFER_BY_USER_ID, GET_USER_ACCOUNT, GET_USER_ACCOUNT_BY_ID, TRANSFER_UNITS, } from './constants';
+import { post } from './utils';
+import * as table from './table';
+var ChainDB = /** @class */ (function () {
+    function ChainDB() {
+        this.api = '';
+        this.name = '';
+        this.access = null;
+        this.access_key = '';
+    }
+    /**
+     * Connection information.
+     * @param server Server location. If the `server` parameter is empty, then "http://localhost" will be used.
+     * @param data_base Data base name
+     * @param user  User to access the data base
+     * @param password  Password to access the data base
+     */
+    ChainDB.prototype.connect = function (server, data_base, user, password) {
+        var key_data = "".concat(data_base).concat(user).concat(password);
+        var key = sha256(key_data);
+        this.api = server || API;
+        this.name = data_base;
+        this.access = new Access(user, password);
+        this.access_key = key;
+    };
+    /**
+     * Create a new user account inside the connected table
+     * @param user_name
+     * @param password
+     * @param units
+     * @param password_hint
+     * @returns
+     */
+    ChainDB.prototype.create_user_account = function (user_name, password, units, password_hint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, body, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.api).concat(CREATE_USER_ACCOUNT);
+                        body = {
+                            db_access_key: this.access_key,
+                            user_name: user_name,
+                            password: password,
+                            password_hint: password_hint,
+                            units: units
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, post(url, body)];
+                    case 2:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.data];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get user account info (login method)
+     * @param user_name
+     * @param password
+     * @returns
+     */
+    ChainDB.prototype.get_user_account = function (user_name, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.api).concat(GET_USER_ACCOUNT, "/").concat(user_name, "/").concat(password, "/").concat(this.access_key);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, axios.get(url)];
+                    case 2:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.data];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get user account info by its id
+     * @param user_id
+     * @returns
+     */
+    ChainDB.prototype.get_user_account_by_id = function (user_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.api).concat(GET_USER_ACCOUNT_BY_ID, "/").concat(user_id, "/").concat(this.access_key);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, axios.get(url)];
+                    case 2:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.data];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check if user_name is already taken
+     * @param user_name
+     */
+    ChainDB.prototype.check_user_name = function (user_name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.api).concat(CHECK_USER_NAME, "/").concat(user_name, "/").concat(this.access_key);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, axios.get(url)];
+                    case 2:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.data];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Transfer units between users
+     * @param from user_id
+     * @param to user_id
+     * @param units
+     * @returns
+     */
+    ChainDB.prototype.transfer_units = function (from, to, units) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, body, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.api).concat(TRANSFER_UNITS);
+                        body = {
+                            db_access_key: this.access_key,
+                            from: from,
+                            to: to,
+                            units: units
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, post(url, body)];
+                    case 2:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.data];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Fetch the last Transference of units Records by User
+     * @param user_id
+     * @returns
+     */
+    ChainDB.prototype.get_transfer_by_user_id = function (user_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.api).concat(GET_TRANSFER_BY_USER_ID, "/").concat(user_id, "/").concat(this.access_key);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, axios.get(url)];
+                    case 2:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.data];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Fetch all Transference of units Records by User
+     * @param user_id
+     * @returns
+     */
+    ChainDB.prototype.get_all_transfers_by_user_id = function (user_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.api).concat(GET_ALL_TRANSFER_BY_USER_ID, "/").concat(user_id, "/").concat(this.access_key);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, axios.get(url)];
+                    case 2:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.data];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Initialize a table, fetching its more updated data
+     */
+    ChainDB.prototype.get_table = function (table_name, model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chainDbCopy, table_data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        chainDbCopy = connect(this.api, this.name, this.access.user, this.access.password);
+                        return [4 /*yield*/, table.get(chainDbCopy, table_name, model)
+                            // NOTE: Although only the "table" and "persist" properties are displayed by
+                            // the lint, all Table properties are being exposed.
+                            // This is due to a javascript limitation on classes.
+                            //
+                            // There was an attempt to return a new object with only the required
+                            // data, but this generates an error in the "this" instance of the Table.
+                        ];
+                    case 1:
+                        table_data = _a.sent();
+                        // NOTE: Although only the "table" and "persist" properties are displayed by
+                        // the lint, all Table properties are being exposed.
+                        // This is due to a javascript limitation on classes.
+                        //
+                        // There was an attempt to return a new object with only the required
+                        // data, but this generates an error in the "this" instance of the Table.
+                        return [2 /*return*/, table_data];
+                }
+            });
+        });
+    };
+    return ChainDB;
+}());
+export { ChainDB };
+export var connect = function (server, data_base, user, password) {
+    var chainDb = new ChainDB();
+    chainDb.connect(server, data_base, user, password);
+    return chainDb;
+};

package/features/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const API = "http://localhost:2818";
+export declare const CONTRACT_PAYLOAD = "/get_last_contract_transaction";
+export declare const CONTRACT_TRANSACTION = "/post_contract_transaction";
+export declare const CREATE_USER_ACCOUNT = "/create_user_account";
+export declare const GET_USER_ACCOUNT = "/get_user_account";
+export declare const GET_USER_ACCOUNT_BY_ID = "/get_user_account_by_id";
+export declare const TRANSFER_UNITS = "/transfer_units";
+export declare const GET_TRANSFER_BY_USER_ID = "/get_transfer_by_user_id";
+export declare const GET_ALL_TRANSFER_BY_USER_ID = "/get_all_transfers_by_user_id";
+export declare const CHECK_USER_NAME = "/check_user_name";

package/features/constants.js

@@ -0,0 +1,11 @@
+// Contants
+export var API = 'http://localhost:2818';
+export var CONTRACT_PAYLOAD = '/get_last_contract_transaction';
+export var CONTRACT_TRANSACTION = '/post_contract_transaction';
+export var CREATE_USER_ACCOUNT = '/create_user_account';
+export var GET_USER_ACCOUNT = '/get_user_account';
+export var GET_USER_ACCOUNT_BY_ID = '/get_user_account_by_id';
+export var TRANSFER_UNITS = '/transfer_units';
+export var GET_TRANSFER_BY_USER_ID = '/get_transfer_by_user_id';
+export var GET_ALL_TRANSFER_BY_USER_ID = '/get_all_transfers_by_user_id';
+export var CHECK_USER_NAME = '/check_user_name';

package/features/table.d.ts

@@ -0,0 +1,13 @@
+import { ChainDB } from './chain-db';
+declare class Table<Model> {
+    table: Model;
+    private contract_id;
+    private db;
+    constructor(table: Model, contract_id: string, db: ChainDB);
+    /**
+     * Persist table data on chain
+     */
+    persist(): Promise<void>;
+}
+export declare const get: <Model>(db: ChainDB, table_name: string, model: Model) => Promise<Table<Model>>;
+export {};

package/features/table.js

@@ -0,0 +1,109 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import axios from 'axios';
+import { CONTRACT_PAYLOAD, CONTRACT_TRANSACTION } from './constants';
+import { TransactionType } from './types';
+import { post } from './utils';
+var Table = /** @class */ (function () {
+    function Table(table, contract_id, db) {
+        this.contract_id = '';
+        this.table = table;
+        this.contract_id = contract_id;
+        this.db = db;
+    }
+    /**
+     * Persist table data on chain
+     */
+    Table.prototype.persist = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, contract_data, body, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.db.api).concat(CONTRACT_TRANSACTION);
+                        contract_data = JSON.stringify(this.table);
+                        body = {
+                            tx_type: TransactionType.CONTRACT,
+                            contract_id: this.contract_id,
+                            db_access_key: this.db.access_key,
+                            data: contract_data
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, post(url, body)];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _b.sent();
+                        throw new Error('Something went wrong!');
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Table;
+}());
+export var get = function (db, table_name, model) { return __awaiter(void 0, void 0, void 0, function () {
+    var contract_id, url, contract_response, contract_data_json, table_1, table, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                contract_id = db.access.parse(db.name, table_name);
+                url = "".concat(db.api).concat(CONTRACT_PAYLOAD, "/").concat(contract_id, "/").concat(db.access_key);
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios.get(url)];
+            case 2:
+                contract_response = _b.sent();
+                contract_data_json = contract_response.data;
+                // If there's already a table (contract) with data, then, fetch its data
+                if (contract_data_json.tx_type === TransactionType.CONTRACT) {
+                    table_1 = new Table(contract_data_json.data, contract_id, db);
+                    return [2 /*return*/, table_1];
+                }
+                table = new Table(model, contract_id, db);
+                return [2 /*return*/, table];
+            case 3:
+                _a = _b.sent();
+                throw new Error('Something went wrong!');
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };

package/features/types.d.ts

@@ -0,0 +1,27 @@
+export type BasicResponse<D> = {
+    success: boolean;
+    error_msg: string;
+    data?: D;
+};
+export type SignedUserAccount = {
+    id: string;
+    user_name: string;
+    units: number;
+};
+export type TransferUnitsRegistry = {
+    from: string;
+    to: string;
+    units: number;
+};
+export declare enum TransactionType {
+    NONE = "NONE",
+    ACCOUNT = "ACCOUNT",
+    CONTRACT = "CONTRACT",
+    TRANSFER = "TRANSFER"
+}
+export type ContractTransactionData<Model> = {
+    tx_type: TransactionType;
+    contract_id: string;
+    timestamp?: number;
+    data: Model;
+};

package/features/types.js

@@ -0,0 +1,7 @@
+export var TransactionType;
+(function (TransactionType) {
+    TransactionType["NONE"] = "NONE";
+    TransactionType["ACCOUNT"] = "ACCOUNT";
+    TransactionType["CONTRACT"] = "CONTRACT";
+    TransactionType["TRANSFER"] = "TRANSFER";
+})(TransactionType || (TransactionType = {}));

package/features/utils.d.ts

@@ -0,0 +1 @@
+export declare const post: (url: string, body: any) => Promise<import("axios").AxiosResponse<any, any>>;

package/features/utils.js

@@ -0,0 +1,4 @@
+import axios from 'axios';
+export var post = function (url, body) {
+    return axios.post(url, body, { headers: { 'content-type': 'application/json' } });
+};

package/index.d.ts

@@ -0,0 +1,3 @@
+export { ChainDB, connect } from './features/chain-db';
+export { Access } from './features/access';
+export { BasicResponse, SignedUserAccount } from './features/types';

package/index.js

@@ -0,0 +1,2 @@
+export { ChainDB, connect } from './features/chain-db';
+export { Access } from './features/access';

package/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src"],
+  "ext": ".ts,.js",
+  "ignore": [],
+  "exec": "npx ts-node ./src/index.ts"
+}