paytonz-node-api-sdk 1.0.0

package/lib/swap/swap.d.ts

@@ -0,0 +1,11 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { SwapCreateInfo, SwapCreateOptions, SwapEstimateInfo, SwapEstimateOptions, SwapHistoryInfo, SwapHistoryListOptions } from "./swap.interface";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class Swap extends PaytonzSDKBase {
+    constructor(parameters: PaytonzSDKOptions);
+    estimate(options: SwapEstimateOptions, accessToken?: string): Promise<SwapEstimateInfo[]>;
+    bestOffer(options: SwapEstimateOptions, accessToken?: string): Promise<SwapEstimateInfo>;
+    create(options: SwapCreateOptions, accessToken?: string): Promise<SwapCreateInfo>;
+    history(options: SwapHistoryListOptions, accessToken?: string): Promise<SwapHistoryInfo>;
+}

package/lib/swap/swap.interface.d.ts

@@ -0,0 +1,84 @@
+import { AccessWalletOptions } from "src/interfaces/paytonz.interface";
+export interface SwapEstimateOptions {
+    fromId: string;
+    toId: string;
+    amount: string;
+    sort?: string;
+    type?: string;
+}
+export interface SwapCreateOptions extends AccessWalletOptions {
+    currencyFromId: string;
+    toId: string;
+    currencyToId: string;
+    amount: number;
+    partner: string;
+    fixed: boolean;
+    rateId: string;
+    idempotencyKey?: string;
+}
+export interface SwapEstimateInfo {
+    id: string;
+    supportRate: number;
+    duration: string;
+    min: number;
+    max: number;
+    fixed: boolean;
+    partner: string;
+    exists: boolean;
+    fromAmount: number;
+    fromCurrency: string;
+    fromNetwork: string;
+    toAmount: number;
+    toCurrency: string;
+    toNetwork: string;
+}
+export interface SwapCreateInfo {
+    id: string;
+    exchangeId: string;
+}
+export interface SwapHistoryListOptions {
+    currencyFromId?: string;
+    currencyToId?: string;
+    search?: string;
+    sort?: string;
+    order?: string;
+    page?: number;
+    limit?: number;
+}
+interface SwapWalletInfo {
+    id: string;
+    address: string;
+    amount: {
+        value: number;
+        usd: number;
+    };
+    currency: {
+        id: string;
+        name: string;
+    };
+    paymentId: string;
+    hash: string;
+}
+export interface SwapHistoryInfo {
+    page: number;
+    pages: number;
+    countItems: number;
+    entities: {
+        _id: string;
+        exchangeId: string;
+        partner: string;
+        fixed: boolean;
+        typeNetwork: string;
+        status: boolean;
+        systemStatus: string;
+        convertRate: number;
+        from: SwapWalletInfo;
+        to: SwapWalletInfo;
+        merchant: string;
+        user: string;
+        rateId: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }[];
+}
+export {};

package/lib/swap/swap.interface.js

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

package/lib/swap/swap.js

@@ -0,0 +1,75 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Swap = void 0;
+const PaytonzSDKBase_1 = require("../PaytonzSDKBase");
+class Swap extends PaytonzSDKBase_1.PaytonzSDKBase {
+    constructor(parameters) {
+        super(parameters);
+    }
+    estimate(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/swap/estimate`;
+                return this.auth_get(`${path}`, Object.assign({}, options), accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    bestOffer(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/swap/best-offer`;
+                return this.auth_get(`${path}`, Object.assign({}, options), accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    create(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/swap/create`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    history(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/swap/history`;
+                return this.auth_get(`${path}`, Object.assign({}, options), accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+}
+exports.Swap = Swap;

package/lib/transaction/transaction.d.ts

@@ -0,0 +1,9 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { TransactionListInfo, TransactionListOptions } from "./transaction.interface";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class Transaction extends PaytonzSDKBase {
+    constructor(parameters: PaytonzSDKOptions);
+    list(options: TransactionListOptions, accessToken?: string): Promise<TransactionListInfo>;
+}
+export default Transaction;

package/lib/transaction/transaction.interface.d.ts

@@ -0,0 +1,82 @@
+export interface TransactionListOptions {
+    search?: string;
+    from?: number;
+    to?: number;
+    currencyId?: string;
+    fromUSD?: number;
+    toUSD?: number;
+    type?: string;
+    status?: string;
+    sort?: string;
+    order?: string;
+    page?: number;
+    limit?: number;
+}
+export interface TransactionListInfo {
+    page: number;
+    pages: number;
+    countItem: number;
+    entities: {
+        id: string;
+        type: string;
+        typeNetwork: string;
+        status: boolean;
+        systemStatus: string;
+        merchant: string;
+        user: string;
+        checkout?: {
+            id: string;
+            name: string;
+            description: string;
+            identifier: string;
+            charge: {
+                id: string;
+            };
+        };
+        info: {
+            incomingTxHash: string;
+            currencyId: string;
+            currency: string;
+            nodeType: string;
+            currencyType: string;
+            exchangeId: number;
+            from: string;
+            to: string;
+            fromId: string;
+            toId: string;
+            hashs: [string];
+            addresses: [string];
+            multisend: {
+                address: string;
+                value: string;
+                usd: string;
+            }[];
+            amount: {
+                value: string;
+                usd: number;
+            };
+            minerFee: {
+                value: string;
+                usd: number;
+                currency: string;
+            };
+            systemFee?: {
+                value: string;
+                usd: number;
+                currency: string;
+                hash: string;
+            };
+            call?: {
+                contractAddress: string;
+                method: string;
+                options: Record<string, any>;
+                arguments: any[];
+                value: string;
+            };
+        };
+        fees?: Record<string, any>;
+        errorMessage?: string;
+        createdAt: Date;
+        updatedAt?: Date;
+    }[];
+}

package/lib/transaction/transaction.interface.js

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

package/lib/transaction/transaction.js

@@ -0,0 +1,34 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const PaytonzSDKBase_1 = require("../PaytonzSDKBase");
+class Transaction extends PaytonzSDKBase_1.PaytonzSDKBase {
+    constructor(parameters) {
+        super(parameters);
+    }
+    list(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/transaction/list`;
+                return this.auth_get(`${path}`, Object.assign({}, options), accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+}
+exports.Transaction = Transaction;
+exports.default = Transaction;

package/lib/utils/httpClient.d.ts

@@ -0,0 +1,9 @@
+import { Headers, Method } from "got";
+export interface Options {
+    timeout?: number;
+    headers?: Headers;
+    method?: Method;
+    json?: Record<string, any>;
+    searchParams?: Record<string, any>;
+}
+export declare const request: <T>(url: any, options?: Options) => Promise<T>;

package/lib/utils/httpClient.js

@@ -0,0 +1,64 @@
+"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.request = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const got_1 = __importDefault(require("got"));
+const url_to_options_1 = __importDefault(require("got/dist/source/core/utils/url-to-options"));
+const DEFAULT_HEADER = {
+    "content-type": "application/json;charset=utf-8",
+};
+const keepAliveAgent = new http_1.default.Agent({ keepAlive: true, maxSockets: 256 });
+const keepAliveAgent2 = new https_1.default.Agent({ keepAlive: true, maxSockets: 256 });
+const request = function (url, options = {}) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const instance = got_1.default.extend({
+            request: (url, options, callback) => {
+                if (url.protocol === "https:") {
+                    return https_1.default.request(Object.assign(Object.assign({}, options), (0, url_to_options_1.default)(url)), callback);
+                }
+                return http_1.default.request(Object.assign(Object.assign({}, options), (0, url_to_options_1.default)(url)), callback);
+            },
+        });
+        try {
+            const response = yield instance(url, {
+                method: options.method,
+                timeout: options.timeout || 6000,
+                headers: options.headers || DEFAULT_HEADER,
+                agent: {
+                    http: keepAliveAgent,
+                    https: keepAliveAgent2,
+                },
+                json: options.json,
+                searchParams: options.searchParams,
+            });
+            if (response.statusCode >= 200 && response.statusCode < 300) {
+                return response.body;
+            }
+            if (response.statusMessage) {
+                throw Error(response.statusMessage);
+            }
+        }
+        catch (err) {
+            const parseError = JSON.parse(((_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.body) || '{"message":"Unknown error"}');
+            if (parseError && parseError.data && parseError.data.message) {
+                throw Error(parseError.data.message);
+            }
+            throw Error(err.message);
+        }
+    });
+};
+exports.request = request;

package/lib/wallet/wallet.d.ts

@@ -0,0 +1,16 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { CreateWalletInfo, CreateWalletOptions, WalletInfo } from "./wallet.interface";
+import { WalletSignature } from "./wallet.signature";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class Wallet extends PaytonzSDKBase {
+    constructor(parameters: PaytonzSDKOptions);
+    signature: WalletSignature;
+    createDepositWallet(options: CreateWalletOptions, accessToken?: string): Promise<CreateWalletInfo>;
+    createSmartAccount(accessToken?: string): Promise<boolean>;
+    getWalletInfo(accessToken?: string): Promise<WalletInfo>;
+    getSmartWalletInfo(accessToken?: string): Promise<WalletInfo>;
+    getPrivateKey(accessToken?: string): Promise<string>;
+    getMnemonic(accessToken?: string): Promise<string>;
+}
+export default Wallet;

package/lib/wallet/wallet.interface.d.ts

@@ -0,0 +1,60 @@
+interface WalletTokensData {
+    currencyId: string;
+    currencyName: string;
+    balance: string;
+    holdBalance: string;
+    balanceUSD: string;
+    availableBalance: string;
+    availableBalanceUSD: string;
+}
+interface NftItem {
+    contractAddress: string;
+    tokenId: number;
+    balance: number;
+    holdBalance: number;
+    name: string;
+    symbol: string;
+}
+interface NftData {
+    erc721: NftItem[];
+    erc1155: NftItem[];
+}
+export interface WalletInfo {
+    id: string;
+    address: string;
+    currencyId: string;
+    balance: string;
+    balanceUSD: string;
+    holdBalance: string;
+    availableBalance: string;
+    availableBalanceUSD: string;
+    tokens?: WalletTokensData[];
+    nfts?: NftData;
+}
+export interface CreateWalletOptions {
+    currencyId: string;
+    typeWallet?: string;
+    privateKey?: string;
+    isMnemonic?: boolean;
+    password?: string;
+    setMain?: boolean;
+    isNew?: boolean;
+}
+export interface CreateWalletInfo {
+    id: string;
+    address: string;
+    balance: number;
+    balanceUSD: number;
+    passphrase: string;
+}
+export interface SignatureCommonOptions {
+    password?: string;
+}
+export interface SignatureOnOptions extends SignatureCommonOptions {
+    sign: string;
+}
+export interface SignatureChangePasswordOptions {
+    oldPassword?: string;
+    password: string;
+}
+export {};

package/lib/wallet/wallet.interface.js

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

package/lib/wallet/wallet.js

@@ -0,0 +1,107 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wallet = void 0;
+const PaytonzSDKBase_1 = require("../PaytonzSDKBase");
+const wallet_signature_1 = require("./wallet.signature");
+class Wallet extends PaytonzSDKBase_1.PaytonzSDKBase {
+    constructor(parameters) {
+        super(parameters);
+        this.signature = new wallet_signature_1.WalletSignature(parameters);
+    }
+    createDepositWallet(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken();
+                }
+                const path = `/api/public/wallet/${options.currencyId}`;
+                delete options.currencyId;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    createSmartAccount(accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken();
+                }
+                const path = `/api/public/wallet/smart-account`;
+                return this.auth_post(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    getWalletInfo(accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet`;
+                return this.auth_get(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    getSmartWalletInfo(accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/smart-account`;
+                return this.auth_get(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    getPrivateKey(accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/private-key`;
+                return this.auth_get(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    getMnemonic(accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/mnemonic`;
+                return this.auth_get(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+}
+exports.Wallet = Wallet;
+exports.default = Wallet;

package/lib/wallet/wallet.signature.d.ts

@@ -0,0 +1,14 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { SignatureChangePasswordOptions, SignatureCommonOptions, SignatureOnOptions } from "./wallet.interface";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class WalletSignature extends PaytonzSDKBase {
+    constructor(parameters: PaytonzSDKOptions);
+    on(options: SignatureOnOptions, accessToken?: string): Promise<boolean>;
+    off(options: SignatureCommonOptions, accessToken?: string): Promise<string>;
+    status(accessToken?: string): Promise<boolean>;
+    download(options: SignatureCommonOptions, accessToken?: string): Promise<string>;
+    changePassword(options: SignatureChangePasswordOptions, accessToken?: string): Promise<boolean>;
+    passwordStatus(accessToken?: string): Promise<boolean>;
+}
+export default WalletSignature;