@cityofzion/blockchain-service 0.1.1

package/dist/BSAgreggator.d.ts

@@ -0,0 +1,16 @@
+import { BlockchainService, Claimable } from "./interfaces";
+export declare class BSAgreggator<BSCustom extends BlockchainService = BlockchainService, BSCustomName extends string = string> {
+    readonly blockchainservices: Record<BSCustomName, BSCustom>;
+    private bsList;
+    constructor(blockchainservices: Record<BSCustomName, BSCustom>);
+    private haveBlockchainServices;
+    addBlockchain(name: BSCustomName, blockchain: BSCustom): void;
+    validateAddressesAllBlockchains(address: string): boolean;
+    validateTextAllBlockchains(text: string): boolean;
+    validateWifAllBlockchains(wif: string): boolean;
+    validateEncryptedKeyAllBlockchains(encryptedKey: string): boolean;
+    getBlockchainByAddress(address: string): BlockchainService<BSCustomName> | null;
+    getBlockchainByWif(wif: string): BlockchainService<BSCustomName> | null;
+    getBlockchainByEncryptedKey(encryptedKey: string): BlockchainService<BSCustomName> | null;
+    getBlockchainsClaimable(): (BlockchainService<BSCustomName> & Claimable)[];
+}

package/dist/BSAgreggator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSAgreggator = void 0;
+const excpetions_1 = require("./excpetions");
+class BSAgreggator {
+    constructor(blockchainservices) {
+        this.blockchainservices = blockchainservices;
+        this.bsList = Object.values(blockchainservices);
+    }
+    haveBlockchainServices() {
+        const blockchainservices = Object.values(this.blockchainservices);
+        const rules = [
+            Object.keys(blockchainservices).length > 1,
+            Object.values(blockchainservices).length > 1,
+        ];
+        return rules.every(rule => rule === true);
+    }
+    addBlockchain(name, blockchain) {
+        if (this.blockchainservices[name])
+            excpetions_1.exception.blockchainAlreadyExist(name);
+        this.blockchainservices[name] = blockchain;
+        this.bsList = Object.values(this.blockchainservices);
+    }
+    validateAddressesAllBlockchains(address) {
+        if (this.haveBlockchainServices())
+            excpetions_1.exception.invalidBlockchainService(JSON.stringify(this.blockchainservices));
+        return this.bsList.some(bs => bs.validateAddress(address));
+    }
+    validateTextAllBlockchains(text) {
+        if (this.haveBlockchainServices())
+            excpetions_1.exception.invalidBlockchainService(JSON.stringify(this.blockchainservices));
+        return this.bsList.some(bs => [bs.validateAddress(text), bs.validateEncryptedKey(text), bs.validateWif(text)].some(it => it === true));
+    }
+    validateWifAllBlockchains(wif) {
+        if (this.haveBlockchainServices())
+            excpetions_1.exception.invalidBlockchainService(JSON.stringify(this.blockchainservices));
+        return this.bsList.some(bs => bs.validateWif(wif));
+    }
+    validateEncryptedKeyAllBlockchains(encryptedKey) {
+        if (this.haveBlockchainServices())
+            excpetions_1.exception.invalidBlockchainService(JSON.stringify(this.blockchainservices));
+        return this.bsList.some(bs => bs.validateEncryptedKey(encryptedKey));
+    }
+    getBlockchainByAddress(address) {
+        var _a;
+        if (this.haveBlockchainServices())
+            excpetions_1.exception.invalidBlockchainService(JSON.stringify(this.blockchainservices));
+        return (_a = this.bsList.find(bs => bs.validateAddress(address))) !== null && _a !== void 0 ? _a : null;
+    }
+    getBlockchainByWif(wif) {
+        var _a;
+        if (this.haveBlockchainServices())
+            excpetions_1.exception.invalidBlockchainService(JSON.stringify(this.blockchainservices));
+        return (_a = this.bsList.find(bs => bs.validateWif(wif))) !== null && _a !== void 0 ? _a : null;
+    }
+    getBlockchainByEncryptedKey(encryptedKey) {
+        var _a;
+        if (this.haveBlockchainServices())
+            excpetions_1.exception.invalidBlockchainService(JSON.stringify(this.blockchainservices));
+        return (_a = this.bsList.find(bs => bs.validateEncryptedKey(encryptedKey))) !== null && _a !== void 0 ? _a : null;
+    }
+    getBlockchainsClaimable() {
+        const methodName = { claim: 'claim', getUnclaimed: 'getUnclaimed', tokenClaim: 'tokenClaim' };
+        const claimableBlockchains = this.bsList.filter(blockchain => methodName.claim in blockchain &&
+            methodName.getUnclaimed in blockchain.dataService &&
+            methodName.tokenClaim in blockchain);
+        return claimableBlockchains;
+    }
+}
+exports.BSAgreggator = BSAgreggator;

package/dist/exchanges/flamingo/Flamingo.d.ts

@@ -0,0 +1,8 @@
+import { Currency, Exchange } from '../../interfaces';
+export declare class Flamingo implements Exchange {
+    private request;
+    getTokenPrices(currency: Currency): Promise<{
+        amount: number;
+        Symbol: string;
+    }[]>;
+}

package/dist/exchanges/flamingo/Flamingo.js

@@ -0,0 +1,37 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flamingo = void 0;
+const axios_1 = __importDefault(require("axios"));
+const FlamingoRoutes_1 = require("./FlamingoRoutes");
+class Flamingo {
+    constructor() {
+        this.request = axios_1.default.create({ baseURL: 'https://api.flamingo.finance' });
+    }
+    getTokenPrices(currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: prices } = yield this.request.get(`/${FlamingoRoutes_1.FLAMINGO_TOKENINFO_PRICES}`);
+            let currencyRatio = 1;
+            if (currency !== 'USD') {
+                const { data } = yield this.request.get(`/${(0, FlamingoRoutes_1.FLAMINGO_FIAT_EXCHANGE_RATE)('USD', currency)}`);
+                currencyRatio = data;
+            }
+            return prices.map(price => ({
+                amount: price.usd_price * currencyRatio,
+                Symbol: price.symbol
+            }));
+        });
+    }
+}
+exports.Flamingo = Flamingo;

package/dist/exchanges/flamingo/FlamingoResponses.d.ts

@@ -0,0 +1,4 @@
+export type FlamingoTokenInfoPricesResponse = {
+    symbol: string;
+    usd_price: number;
+}[];

package/dist/exchanges/flamingo/FlamingoResponses.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/exchanges/flamingo/FlamingoRoutes.d.ts

@@ -0,0 +1,3 @@
+import { Currency } from "../../interfaces";
+export declare const FLAMINGO_TOKENINFO_PRICES = "token-info/prices";
+export declare const FLAMINGO_FIAT_EXCHANGE_RATE: (currencyFrom: Currency, currencyTo: Currency) => string;

package/dist/exchanges/flamingo/FlamingoRoutes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLAMINGO_FIAT_EXCHANGE_RATE = exports.FLAMINGO_TOKENINFO_PRICES = void 0;
+exports.FLAMINGO_TOKENINFO_PRICES = 'token-info/prices';
+const FLAMINGO_FIAT_EXCHANGE_RATE = (currencyFrom, currencyTo) => {
+    return `fiat/exchange-rate?pair=${currencyFrom}_${currencyTo}`;
+};
+exports.FLAMINGO_FIAT_EXCHANGE_RATE = FLAMINGO_FIAT_EXCHANGE_RATE;

package/dist/exchanges/index.d.ts

@@ -0,0 +1,7 @@
+export * from './flamingo/Flamingo';
+export * from './flamingo/FlamingoResponses';
+export * from './flamingo/FlamingoRoutes';
+import { Flamingo } from "./flamingo/Flamingo";
+export declare const exchangeOptions: {
+    flamingo: Flamingo;
+};

package/dist/exchanges/index.js

@@ -0,0 +1,24 @@
+"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];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exchangeOptions = void 0;
+__exportStar(require("./flamingo/Flamingo"), exports);
+__exportStar(require("./flamingo/FlamingoResponses"), exports);
+__exportStar(require("./flamingo/FlamingoRoutes"), exports);
+const Flamingo_1 = require("./flamingo/Flamingo");
+exports.exchangeOptions = {
+    flamingo: new Flamingo_1.Flamingo()
+};

package/dist/excpetions.d.ts

@@ -0,0 +1,4 @@
+export declare const exception: {
+    invalidBlockchainService: (message?: string) => never;
+    blockchainAlreadyExist: (blockchainName: string) => never;
+};

package/dist/excpetions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exception = void 0;
+exports.exception = {
+    invalidBlockchainService: (message) => {
+        throw new Error(`Invalid blockchainServices => ${message}`);
+    },
+    blockchainAlreadyExist: (blockchainName) => {
+        throw new Error(`The blockchain ${blockchainName} already exist`);
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './BSAgreggator';
+export * from './exchanges';

package/dist/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];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./BSAgreggator"), exports);
+__exportStar(require("./exchanges"), exports);

package/dist/interfaces.d.ts

@@ -0,0 +1,180 @@
+export type SendTransactionParam = {
+    senderAccount: Account;
+    transactionIntents: IntentTransactionParam[];
+    priorityFee?: number;
+};
+export type IntentTransactionParam = {
+    receiverAddress: string;
+    tokenHash: string;
+    amount: number;
+};
+export interface Account {
+    getWif(): string;
+    getAddress(): string;
+}
+export type CalculateTransferFeeDetails = {
+    systemFee?: string;
+    networkFee?: string;
+};
+export type Currency = "USD" | "BRL" | "EUR";
+export type ExchangeInfo = {
+    symbol: string;
+    amount: number;
+};
+export interface Claimable {
+    claim(account: Account): Promise<{
+        txid: string;
+        symbol: string;
+        hash: string;
+    }>;
+    dataService: BlockchainDataService & BDSClaimable;
+    tokenClaim: {
+        hash: string;
+        symbol: string;
+        decimals: number;
+    };
+}
+export declare enum NNSRecordTypes {
+    IPV4 = "1",
+    CANONICAL_NAME = "5",
+    TEXT = "16",
+    IPV6 = "28"
+}
+export type NNSResponse = {
+    jsonrpc: string;
+    id: number;
+    result: {
+        script: string;
+        state: string;
+        gasconsumed: string;
+        exception: string;
+        stack: {
+            type: string;
+            value: string;
+        }[];
+    };
+};
+export interface NeoNameService {
+    getNeoNsRecord(domainName: string, type: typeof NNSRecordTypes): Promise<NNSResponse>;
+    getOwnerOfNeoNsRecord(domainName: string): Promise<NNSResponse>;
+}
+export type Token = {
+    name: string;
+    symbol: string;
+    hash: string;
+    decimals: number;
+};
+export interface BlockchainService<BSCustomName extends string = string> {
+    readonly dataService: BlockchainDataService;
+    readonly blockchainName: BSCustomName;
+    readonly derivationPath: string;
+    readonly feeToken: {
+        hash: string;
+        symbol: string;
+        decimals: number;
+    };
+    readonly exchange: Exchange;
+    readonly tokens: Token[];
+    sendTransaction(param: SendTransactionParam): Promise<string>;
+    generateMnemonic(): string;
+    generateWif(mnemonic: string, index: number): string;
+    generateAccount(mnemonic: string, index: number): {
+        wif: string;
+        address: string;
+    };
+    generateAccountFromWif(wif: string): string;
+    decryptKey(encryptedKey: string, password: string): Promise<{
+        wif: string;
+        address: string;
+    }>;
+    validateAddress(address: string): boolean;
+    validateEncryptedKey(encryptedKey: string): boolean;
+    validateWif(wif: string): boolean;
+    calculateTransferFee(param: SendTransactionParam, details?: boolean): Promise<{
+        result: number;
+        details?: CalculateTransferFeeDetails;
+    }>;
+}
+export type TransactionNotifications = {
+    contract: string;
+    event_name: string;
+    state: {
+        type: string;
+        value: string;
+    }[];
+};
+export type TransactionResponse = {
+    txid: string;
+    block: number;
+    time: string;
+    transfers: Omit<TransactionTransfer, 'txid'>[];
+    sysfee: string;
+    netfee: string;
+    totfee: string;
+    notifications: TransactionNotifications[];
+};
+export type TransactionTransfer = {
+    amount: string;
+    to: string;
+    from: string;
+    hash: string;
+    txid: string;
+};
+export type ContractParameter = {
+    name: string;
+    type: string;
+};
+export type TransactionHistoryResponse = {
+    totalCount: number;
+    transactions: TransactionResponse[];
+};
+export type ContractMethod = {
+    name: string;
+    parameters: ContractParameter[];
+};
+export type ContractResponse = {
+    hash: string;
+    name: string;
+    methods: ContractMethod[];
+};
+export type ConsensusNodeResponse = {
+    url: string;
+    height: number;
+};
+export type TokenInfoResponse = {
+    symbol: string;
+    decimals: number;
+};
+export type BlockchainNetwork = "mainnet" | "testnet" | "privatenet";
+export type BalanceResponse = {
+    amount: number;
+    hash: string;
+    symbol: string;
+    name: string;
+};
+export type UnclaimedResponse = {
+    address: string;
+    unclaimed: number;
+};
+export interface BDSClaimable {
+    getUnclaimed(address: string): Promise<UnclaimedResponse>;
+}
+export interface BlockchainDataService {
+    readonly explorer: string;
+    network: BlockchainNetwork;
+    setNetwork(network: BlockchainNetwork): void;
+    getTransaction(txid: string): Promise<TransactionResponse>;
+    getHistoryTransactions(address: string, page: number): Promise<TransactionHistoryResponse>;
+    getContract(contractHash: string): Promise<ContractResponse>;
+    getTokenInfo(tokenHash: string): Promise<TokenInfoResponse>;
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    getAllNodes(): Promise<ConsensusNodeResponse[]>;
+    getHigherNode(): Promise<ConsensusNodeResponse>;
+}
+export type ToeknPricesResponse = {
+    amount: number;
+    Symbol: string;
+};
+export interface Exchange {
+    getTokenPrices(currency: Currency): Promise<ToeknPricesResponse[]>;
+}

package/dist/interfaces.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NNSRecordTypes = void 0;
+var NNSRecordTypes;
+(function (NNSRecordTypes) {
+    NNSRecordTypes["IPV4"] = "1";
+    NNSRecordTypes["CANONICAL_NAME"] = "5";
+    NNSRecordTypes["TEXT"] = "16";
+    NNSRecordTypes["IPV6"] = "28";
+})(NNSRecordTypes = exports.NNSRecordTypes || (exports.NNSRecordTypes = {}));
+//*****************************************************************************

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@cityofzion/blockchain-service",
+  "version": "0.1.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Coz",
+  "license": "MIT",
+  "files": ["/dist"],
+  "scripts": {
+    "build": "tsc && typedoc src/index.ts"
+  },
+  "dependencies": {
+    "axios": "1.3.2"
+  },
+  "devDependencies": {
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5",
+    "typedoc": "0.23.24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CityOfZion/blockchain-services",
+    "directory": "packages/blockchain-service"
+  }
+}