@pioneer-platform/changelly-client 8.3.1

package/lib/client.d.ts

@@ -0,0 +1,19 @@
+type CallbackFunction = (err: Error | null, response?: any) => void;
+declare class Changelly {
+    private apiKey;
+    private apiSecret;
+    private client;
+    private _socket;
+    constructor(apiKey: string, apiSecret: string);
+    private _id;
+    private _sign;
+    private _request;
+    getCurrencies(callback: CallbackFunction): void;
+    createTransaction(from: string, to: string, address: string, amount: number, extraId: string | null, callback: CallbackFunction): void;
+    getMinAmount(from: string, to: string, callback: CallbackFunction): void;
+    getExchangeAmount(from: string, to: string, amount: number, callback: CallbackFunction): void;
+    getTransactions(limit: number, offset: number, currency: string, address: string, extraId: string, callback: CallbackFunction): void;
+    getStatus(id: string, callback: CallbackFunction): void;
+    on(channel: string, callback: (...args: any[]) => void): void;
+}
+export = Changelly;

package/lib/client.js

@@ -0,0 +1,101 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var io = __importStar(require("socket.io-client"));
+// @ts-ignore
+var jayson = __importStar(require("jayson"));
+var crypto = __importStar(require("crypto"));
+var Changelly = /** @class */ (function () {
+    function Changelly(apiKey, apiSecret) {
+        var _this = this;
+        this.apiKey = apiKey;
+        this.apiSecret = apiSecret;
+        // @ts-ignore
+        this.client = jayson.client.https('https://api.changelly.com');
+        this._socket = io.connect('https://api.changelly.com', {
+            reconnection: true,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 5000,
+            reconnectionAttempts: Infinity,
+        });
+        this._socket.on('connect', function () {
+            var message = { "Login": {} };
+            _this._socket.emit('subscribe', {
+                apiKey: _this.apiKey,
+                sign: _this._sign(message),
+                message: message
+            });
+        });
+    }
+    Changelly.prototype._id = function () {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = Math.random() * 16 | 0;
+            var v = c == 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    };
+    Changelly.prototype._sign = function (message) {
+        return crypto
+            .createHmac('sha512', this.apiSecret)
+            .update(JSON.stringify(message))
+            .digest('hex');
+    };
+    Changelly.prototype._request = function (method, options, callback) {
+        var id = this._id();
+        var message = jayson.utils.request(method, options, id);
+        this.client.options.headers = {
+            'api-key': this.apiKey,
+            'sign': this._sign(message)
+        };
+        this.client.request(method, options, id, callback);
+    };
+    Changelly.prototype.getCurrencies = function (callback) {
+        this._request('getCurrencies', {}, callback);
+    };
+    Changelly.prototype.createTransaction = function (from, to, address, amount, extraId, callback) {
+        var params = { from: from, to: to, address: address, amount: amount, extraId: extraId };
+        this._request('createTransaction', params, callback);
+    };
+    Changelly.prototype.getMinAmount = function (from, to, callback) {
+        var params = { from: from, to: to };
+        this._request('getMinAmount', params, callback);
+    };
+    Changelly.prototype.getExchangeAmount = function (from, to, amount, callback) {
+        var params = { from: from, to: to, amount: amount };
+        this._request('getExchangeAmount', params, callback);
+    };
+    Changelly.prototype.getTransactions = function (limit, offset, currency, address, extraId, callback) {
+        var params = { limit: limit, offset: offset, currency: currency, address: address, extraId: extraId };
+        this._request('getTransactions', params, callback);
+    };
+    Changelly.prototype.getStatus = function (id, callback) {
+        var params = { id: id };
+        this._request('getStatus', params, callback);
+    };
+    Changelly.prototype.on = function (channel, callback) {
+        this._socket.on(channel, callback);
+    };
+    return Changelly;
+}());
+module.exports = Changelly;

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+declare let Changelly: any;
+declare const TAG = " | blocknative | ";
+declare const CHANGELLY_API_KEY: string | undefined;
+declare const CHANGELLY_API_SECRET: string | undefined;
+declare let changelly: any;
+declare let shortListSymbolToCaip: any;
+declare let networkSupport: any[];
+declare function get_currencies(): Promise<any>;
+declare function create_transaction(from: string, to: string, address: string, amount: number, extraId?: string): Promise<any>;
+declare function get_min_amount(from: string, to: string): Promise<any>;
+declare function get_exchange_amount(from: string, to: string, amount: number): Promise<any>;
+declare function get_transactions(limit: number, offset: number, currency?: string, address?: string, extraId?: string): Promise<any>;
+declare function get_status(id: string): Promise<any>;

package/lib/index.js

@@ -0,0 +1,221 @@
+"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 __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 };
+    }
+};
+var Changelly = require('@bithighlander/changelly');
+var TAG = " | blocknative | ";
+var CHANGELLY_API_KEY = process.env['CHANGELLY_API_KEY'];
+var CHANGELLY_API_SECRET = process.env['CHANGELLY_API_SECRET'];
+if (!CHANGELLY_API_KEY)
+    throw new Error('CHANGELLY_API_KEY not set');
+if (!CHANGELLY_API_SECRET)
+    throw new Error('CHANGELLY_API_SECRET not set');
+var changelly;
+var shortListSymbolToCaip = require("@pioneer-platform/pioneer-caip").shortListSymbolToCaip;
+var networkSupport = [
+    shortListSymbolToCaip["XRP"],
+    shortListSymbolToCaip["DASH"],
+    shortListSymbolToCaip["ZEC"],
+    // shortListSymbolToCaip["BSV"], //TODO
+    // shortListSymbolToCaip["ADA"], //TODO
+    // shortListSymbolToCaip["EOS"], //TODO
+    shortListSymbolToCaip["GAIA"],
+    shortListSymbolToCaip["BNB"],
+    shortListSymbolToCaip["DOGE"],
+    shortListSymbolToCaip["BTC"],
+    shortListSymbolToCaip["ETH"],
+    shortListSymbolToCaip["LTC"],
+    shortListSymbolToCaip["THOR"],
+    shortListSymbolToCaip["BCH"],
+    shortListSymbolToCaip["GNO"],
+    shortListSymbolToCaip["MATIC"],
+    shortListSymbolToCaip["AVAX"],
+];
+module.exports = {
+    init: function (settings) {
+        changelly = new Changelly(CHANGELLY_API_KEY, CHANGELLY_API_SECRET);
+    },
+    networkSupport: function () {
+        return networkSupport;
+    },
+    getCurrenciesAsync: function () {
+        return get_currencies();
+    },
+    getQuote: function (from, to, address, amount, extraId) {
+        return create_transaction(from, to, address, amount, extraId);
+    },
+    // createTransactionAsync: function(from: string, to: string, address: string, amount: number, extraId?: string): Promise<any> {
+    //     return create_transaction(from, to, address, amount, extraId);
+    // },
+    getMinAmountAsync: function (from, to) {
+        return get_min_amount(from, to);
+    },
+    getExchangeAmountAsync: function (from, to, amount) {
+        return get_exchange_amount(from, to, amount);
+    },
+    getTransactionsAsync: function (limit, offset, currency, address, extraId) {
+        return get_transactions(limit, offset, currency, address, extraId);
+    },
+    getStatusAsync: function (id) {
+        return get_status(id);
+    }
+};
+function get_currencies() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        changelly.getCurrencies(function (err, data) {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(data);
+                        });
+                    })];
+            }
+            catch (e) {
+                console.error(TAG, "get_currencies error:", e);
+                throw e;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function create_transaction(from, to, address, amount, extraId) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        changelly.createTransaction(from, to, address, amount, extraId, function (err, data) {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(data);
+                        });
+                    })];
+            }
+            catch (e) {
+                console.error(TAG, "create_transaction error:", e);
+                throw e;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function get_min_amount(from, to) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        changelly.getMinAmount(from, to, function (err, data) {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(data);
+                        });
+                    })];
+            }
+            catch (e) {
+                console.error(TAG, "get_min_amount error:", e);
+                throw e;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function get_exchange_amount(from, to, amount) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        changelly.getExchangeAmount(from, to, amount, function (err, data) {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(data);
+                        });
+                    })];
+            }
+            catch (e) {
+                console.error(TAG, "get_exchange_amount error:", e);
+                throw e;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function get_transactions(limit, offset, currency, address, extraId) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        changelly.getTransactions(limit, offset, currency, address, extraId, function (err, data) {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(data);
+                        });
+                    })];
+            }
+            catch (e) {
+                console.error(TAG, "get_transactions error:", e);
+                throw e;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+function get_status(id) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        changelly.getStatus(id, function (err, data) {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(data);
+                        });
+                    })];
+            }
+            catch (e) {
+                console.error(TAG, "get_status error:", e);
+                throw e;
+            }
+            return [2 /*return*/];
+        });
+    });
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@pioneer-platform/changelly-client",
+  "version": "8.3.1",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@bithighlander/changelly": "^1.0.0",
+    "@pioneer-platform/loggerdog": "^8.3.1",
+    "axios": "^1.3.4",
+    "dotenv": "^8.2.0",
+    "jayson": "^4.1.0",
+    "micro-ftch": "^0.3.1"
+  },
+  "scripts": {
+    "npm": "npm i",
+    "test": "npm run build && node __tests__/test-module.js",
+    "build": "tsc -p .",
+    "prepublish": "npm run build",
+    "refresh": "rm -rf ./node_modules ./package-lock.json && npm install"
+  },
+  "devDependencies": {
+    "@types/jest": "^25.2.3",
+    "@types/node": "^13.13.21",
+    "@types/source-map-support": "^0.5.3",
+    "jest": "^26.4.2",
+    "onchange": "^7.0.2",
+    "serve": "^11.3.2",
+    "source-map-support": "^0.5.19",
+    "ts-jest": "^29.0.5",
+    "typescript": "^5.0.2"
+  },
+  "gitHead": "aeae28273014ab69b42f22abec159c6693a56c40"
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": ["es6", "es2015", "dom"],
+    "declaration": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "strict": true,
+    "types": ["node"],
+    "esModuleInterop": true
+  }
+}