bitapy-sdk 6.2.1

package/dist/Model/Webhook/RefundWebhook.zod.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refundWebhookSchema = void 0;
+const zod_1 = require("zod");
+exports.refundWebhookSchema = zod_1.z.object({
+    amount: zod_1.z.number().nullable(),
+    buyerPaysRefundFee: zod_1.z.boolean().nullable(),
+    currency: zod_1.z.string().nullable(),
+    id: zod_1.z.string().nullable(),
+    immediate: zod_1.z.boolean().nullable(),
+    invoice: zod_1.z.string().nullable(),
+    lastRefundNotification: zod_1.z.string().nullable(),
+    refundFee: zod_1.z.number().nullable(),
+    requestDate: zod_1.z.string().nullable(),
+    status: zod_1.z.string().nullable(),
+    supportRequest: zod_1.z.string().nullable(),
+    reference: zod_1.z.string().nullable(),
+    guid: zod_1.z.string().nullable(),
+    refundAddress: zod_1.z.string().nullable(),
+    type: zod_1.z.string().nullable(),
+    txid: zod_1.z.string().nullable(),
+    transactionCurrency: zod_1.z.string().nullable(),
+    transactionAmount: zod_1.z.number().nullable(),
+    transactionRefundFee: zod_1.z.number().nullable()
+});
+//# sourceMappingURL=RefundWebhook.zod.js.map

package/dist/Model/index.d.ts

@@ -0,0 +1,12 @@
+import { Invoice, InvoiceInterface } from './Invoice/Invoice';
+import { RateInterface } from './Rates/Rate';
+import { Rates } from './Rates/Rates';
+import { Bill, BillInterface } from './Bill/Bill';
+import { Item as BillItem } from './Bill/Item';
+import { LedgerInterface } from './Ledger/Ledger';
+import { LedgerEntryInterface } from './Ledger/LedgerEntry';
+import { PayoutRecipient, PayoutRecipientInterface } from './Payout/PayoutRecipient';
+import { PayoutRecipients, PayoutRecipientsInterface } from './Payout/PayoutRecipients';
+import { Payout, PayoutInterface } from './Payout/Payout';
+import { PayoutGroupInterface } from './Payout/PayoutGroup';
+export { Invoice, InvoiceInterface, RateInterface, Rates, Bill, BillInterface, BillItem, LedgerInterface, LedgerEntryInterface, PayoutRecipient, PayoutRecipientInterface, PayoutRecipients, PayoutRecipientsInterface, Payout, PayoutInterface, PayoutGroupInterface };

package/dist/Model/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ *     __    _ __
+ *    / /_  (_) /_____  ____ ___  __
+ *   / __ \/ / __/ __ \/ __ `/ / / /
+ *  / /_/ / / /_/ /_/ / /_/ / /_/ /
+ * /_.___/_/\__/ .___/\__,_/\__, /
+ *            /_/          /____/
+ *
+ * BitPay NodeJS Client
+ *
+ * Copyright (c) 2020 BitPay inc.
+ * This file is open source and available under the MIT license.
+ * See the LICENSE file for more info.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Payout = exports.PayoutRecipients = exports.PayoutRecipient = exports.BillItem = exports.Bill = exports.Rates = exports.Invoice = void 0;
+const Invoice_1 = require("./Invoice/Invoice");
+Object.defineProperty(exports, "Invoice", { enumerable: true, get: function () { return Invoice_1.Invoice; } });
+const Rates_1 = require("./Rates/Rates");
+Object.defineProperty(exports, "Rates", { enumerable: true, get: function () { return Rates_1.Rates; } });
+const Bill_1 = require("./Bill/Bill");
+Object.defineProperty(exports, "Bill", { enumerable: true, get: function () { return Bill_1.Bill; } });
+const Item_1 = require("./Bill/Item");
+Object.defineProperty(exports, "BillItem", { enumerable: true, get: function () { return Item_1.Item; } });
+const PayoutRecipient_1 = require("./Payout/PayoutRecipient");
+Object.defineProperty(exports, "PayoutRecipient", { enumerable: true, get: function () { return PayoutRecipient_1.PayoutRecipient; } });
+const PayoutRecipients_1 = require("./Payout/PayoutRecipients");
+Object.defineProperty(exports, "PayoutRecipients", { enumerable: true, get: function () { return PayoutRecipients_1.PayoutRecipients; } });
+const Payout_1 = require("./Payout/Payout");
+Object.defineProperty(exports, "Payout", { enumerable: true, get: function () { return Payout_1.Payout; } });
+//# sourceMappingURL=index.js.map

package/dist/PosToken.d.ts

@@ -0,0 +1,13 @@
+export declare class PosToken {
+    private readonly value;
+    /**
+     *
+     * @param value
+     */
+    constructor(value: string);
+    /**
+     *
+     * @returns string
+     */
+    getValue(): string;
+}

package/dist/PosToken.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PosToken = void 0;
+class PosToken {
+    /**
+     *
+     * @param value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     *
+     * @returns string
+     */
+    getValue() {
+        return this.value;
+    }
+}
+exports.PosToken = PosToken;
+//# sourceMappingURL=PosToken.js.map

package/dist/PrivateKey.d.ts

@@ -0,0 +1,9 @@
+export declare class PrivateKey {
+    private readonly value;
+    constructor(value: string);
+    /**
+     *
+     * @returns string
+     */
+    getValue(): string;
+}

package/dist/PrivateKey.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateKey = void 0;
+class PrivateKey {
+    constructor(value) {
+        value = value.replace('"', '');
+        this.value = value;
+    }
+    /**
+     *
+     * @returns string
+     */
+    getValue() {
+        return this.value;
+    }
+}
+exports.PrivateKey = PrivateKey;
+//# sourceMappingURL=PrivateKey.js.map

package/dist/TokenContainer.d.ts

@@ -0,0 +1,39 @@
+import { Facade } from './Facade';
+export declare class TokenContainer {
+    private readonly data;
+    constructor(tokens?: object);
+    /**
+     *
+     * @param key
+     * @returns string
+     * @throws BitPayGenericException BitPayGenericException class
+     */
+    getToken(key: string): string;
+    /**
+     *
+     * @param token
+     */
+    addPos(token: string): void;
+    /**
+     *
+     * @param token
+     */
+    addMerchant(token: string): void;
+    /**
+     *
+     * @param token
+     */
+    addPayout(token: string): void;
+    /**
+     *
+     * @param facade
+     * @returns
+     */
+    isTokenExist(facade: Facade): boolean;
+    /**
+     *
+     * @param facade
+     * @param token
+     */
+    private add;
+}

package/dist/TokenContainer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenContainer = void 0;
+const Facade_1 = require("./Facade");
+const BitPayExceptionProvider_1 = require("./Exceptions/BitPayExceptionProvider");
+class TokenContainer {
+    constructor(tokens) {
+        this.data = new Map();
+        if (tokens !== undefined) {
+            Object.keys(tokens).forEach((key) => {
+                this.add(key, String(tokens[key]));
+            });
+        }
+    }
+    /**
+     *
+     * @param key
+     * @returns string
+     * @throws BitPayGenericException BitPayGenericException class
+     */
+    getToken(key) {
+        if (!this.data.has(key)) {
+            BitPayExceptionProvider_1.BitPayExceptionProvider.throwGenericExceptionWithMessage('There is no token for the specified key : ' + key);
+            throw new Error();
+        }
+        const value = this.data.get(key);
+        if (value === undefined) {
+            throw new Error();
+        }
+        return value;
+    }
+    /**
+     *
+     * @param token
+     */
+    addPos(token) {
+        this.data.set(Facade_1.Facade.Pos, token);
+    }
+    /**
+     *
+     * @param token
+     */
+    addMerchant(token) {
+        this.data.set(Facade_1.Facade.Merchant, token);
+    }
+    /**
+     *
+     * @param token
+     */
+    addPayout(token) {
+        this.data.set(Facade_1.Facade.Payout, token);
+    }
+    /**
+     *
+     * @param facade
+     * @returns
+     */
+    isTokenExist(facade) {
+        return this.data.has(facade);
+    }
+    /**
+     *
+     * @param facade
+     * @param token
+     */
+    add(facade, token) {
+        this.data.set(facade, token);
+    }
+}
+exports.TokenContainer = TokenContainer;
+//# sourceMappingURL=TokenContainer.js.map

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { KeyUtils } from './util/KeyUtils';
+import * as BitPayExceptions from './Exceptions/index';
+import * as Models from './Model/index';
+import { Client } from './Client';
+import { Config } from './Config';
+import { Currency } from './Currency';
+import { Facade } from './Facade';
+import * as Env from './Env';
+import * as Invoice from './Model/Invoice/Invoice';
+import * as InvoiceStatus from './Model/Invoice/InvoiceStatus';
+import * as RefundStatus from './Model/Invoice/RefundStatus';
+import * as RecipientStatus from './Model/Payout/RecipientStatus';
+import * as RecipientReferenceMethod from './Model/Payout/RecipientReferenceMethod';
+import * as PayoutStatus from './Model/Payout/PayoutStatus';
+export { KeyUtils, BitPayExceptions, Models, Config, Env, Facade, Currency, Client, Invoice, InvoiceStatus, RefundStatus, RecipientStatus, RecipientReferenceMethod, PayoutStatus };

package/dist/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/*
+ *     __    _ __
+ *    / /_  (_) /_____  ____ ___  __
+ *   / __ \/ / __/ __ \/ __ `/ / / /
+ *  / /_/ / / /_/ /_/ / /_/ / /_/ /
+ * /_.___/_/\__/ .___/\__,_/\__, /
+ *            /_/          /____/
+ *
+ * BitPay NodeJS Client
+ *
+ * Copyright (c) 2020 BitPay inc.
+ * This file is open source and available under the MIT license.
+ * See the LICENSE file for more info.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayoutStatus = exports.RecipientReferenceMethod = exports.RecipientStatus = exports.RefundStatus = exports.InvoiceStatus = exports.Invoice = exports.Client = exports.Currency = exports.Facade = exports.Env = exports.Config = exports.Models = exports.BitPayExceptions = exports.KeyUtils = void 0;
+const KeyUtils_1 = require("./util/KeyUtils");
+Object.defineProperty(exports, "KeyUtils", { enumerable: true, get: function () { return KeyUtils_1.KeyUtils; } });
+const BitPayExceptions = require("./Exceptions/index");
+exports.BitPayExceptions = BitPayExceptions;
+const Models = require("./Model/index");
+exports.Models = Models;
+const Client_1 = require("./Client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return Client_1.Client; } });
+const Config_1 = require("./Config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return Config_1.Config; } });
+const Currency_1 = require("./Currency");
+Object.defineProperty(exports, "Currency", { enumerable: true, get: function () { return Currency_1.Currency; } });
+const Facade_1 = require("./Facade");
+Object.defineProperty(exports, "Facade", { enumerable: true, get: function () { return Facade_1.Facade; } });
+const Env = require("./Env");
+exports.Env = Env;
+const Invoice = require("./Model/Invoice/Invoice");
+exports.Invoice = Invoice;
+const InvoiceStatus = require("./Model/Invoice/InvoiceStatus");
+exports.InvoiceStatus = InvoiceStatus;
+const RefundStatus = require("./Model/Invoice/RefundStatus");
+exports.RefundStatus = RefundStatus;
+const RecipientStatus = require("./Model/Payout/RecipientStatus");
+exports.RecipientStatus = RecipientStatus;
+const RecipientReferenceMethod = require("./Model/Payout/RecipientReferenceMethod");
+exports.RecipientReferenceMethod = RecipientReferenceMethod;
+const PayoutStatus = require("./Model/Payout/PayoutStatus");
+exports.PayoutStatus = PayoutStatus;
+//# sourceMappingURL=index.js.map

package/dist/setup/BitPaySetup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/setup/BitPaySetup.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const BitPaySDK = require("../index");
+const readline = require("readline");
+const privateKeyPath = __dirname + '/../secure/private_key';
+const ConfFilePath = __dirname + '/../secure/BitPay.config.json';
+const keyUtils = new BitPaySDK.KeyUtils();
+let keyPair;
+let ecKey;
+let environment;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+let storeFile = true;
+let apiUrl;
+let merchantToken;
+let merchantPairCode;
+let payoutToken;
+let payoutPairCode;
+let keyPath = '';
+let keyPlain = '';
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+const main = function () {
+    selectEnv();
+};
+const selectEnv = async () => {
+    try {
+        console.log('Select target environment:');
+        rl.question('Press T for testing or P for production: \n', async (answer) => {
+            switch (answer.toLowerCase()) {
+                case 't':
+                    environment = 'Test';
+                    await setEnv(environment);
+                    selectCreateKey();
+                    break;
+                case 'p':
+                    environment = 'Prod';
+                    await setEnv(environment);
+                    selectCreateKey();
+                    break;
+                default:
+                    selectEnv();
+            }
+        });
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+const setEnv = async (env) => {
+    if (env == 'Test') {
+        apiUrl = 'https://test.bitpay.com';
+        return;
+    }
+    apiUrl = 'https://bitpay.com';
+};
+const selectCreateKey = async () => {
+    try {
+        console.log('Enter your private key or its location');
+        rl.question('Or press Enter to generate a brand new key: ', async (answer) => {
+            switch (answer.toLowerCase()) {
+                case '':
+                    await createNewKey();
+                    break;
+                default:
+                    await loadKey(answer);
+                    break;
+            }
+        });
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+const createNewKey = async () => {
+    try {
+        console.log('Generating private key... \n');
+        keyPair = keyUtils.generate_keypair();
+        ecKey = keyUtils.load_keypair(keyPair);
+        await sleep(2000);
+        console.log('Generated Private Key: ' + ecKey.getPrivate('hex'));
+        console.log('With Public Key: ' + ecKey.getPublic('hex') + '\n');
+        await storeKey();
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+const loadKey = async (privateKey) => {
+    try {
+        if (fs.existsSync(privateKey)) {
+            console.log('Loading private key... \n');
+            await sleep(2000);
+            ecKey = keyUtils.load_keypair(fs.readFileSync(privateKey).toString().trim());
+            console.log('Loaded Private Key: ' + ecKey.getPrivate('hex'));
+            console.log('With Public Key: ' + keyUtils.getPublicKeyFromPrivateKey(ecKey));
+            console.log('From: ' + privateKey);
+            console.log('\n');
+            selectTokens();
+        }
+        else {
+            ecKey = keyUtils.load_keypair(privateKey);
+            console.log('Loading private key... \n');
+            await sleep(2000);
+            console.log('Loaded Private Key: ' + ecKey.getPrivate('hex'));
+            console.log('With Public Key: ' + keyUtils.getPublicKeyFromPrivateKey(ecKey));
+            console.log('From: ' + privateKey);
+            console.log('\n');
+            selectTokens();
+        }
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+const storeKey = async () => {
+    try {
+        if (!fs.existsSync(__dirname + '/../secure')) {
+            fs.mkdirSync(__dirname + '/../secure');
+        }
+        console.log('Select the way you want to store your private key:');
+        rl.question('Press F for storing in a text file or T for plain text in your config file: ', async (answer) => {
+            switch (answer.toLowerCase()) {
+                case 'f':
+                    storeFile = true;
+                    keyPath = privateKeyPath + '_' + environment.toLowerCase() + '.key';
+                    console.log('Saving private key... \n');
+                    sleep(500);
+                    fs.writeFile(privateKeyPath + '_' + environment.toLowerCase() + '.key', ecKey.getPrivate('hex'), { mode: 0o755 }, function (err) {
+                        if (err)
+                            throw err;
+                        console.log('Private key saved in file: ' + keyPath + '\n');
+                    });
+                    await sleep(1000);
+                    selectTokens();
+                    break;
+                case 't':
+                    storeFile = false;
+                    keyPlain = ecKey.getPrivate('hex');
+                    console.log('Saving private key... \n');
+                    await sleep(1000);
+                    selectTokens();
+                    break;
+                default:
+                    storeKey();
+            }
+        });
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+const selectTokens = async () => {
+    try {
+        console.log('Select the tokens that you would like to request:');
+        rl.question('Press M for merchant, P for payout, or B for both: \n', async (answer) => {
+            switch (answer.toLowerCase()) {
+                case 'm':
+                case 'p':
+                case 'b':
+                    console.log('Requesting tokens... \n');
+                    await sleep(500);
+                    await requestTokens(answer);
+                    break;
+                default:
+                    selectTokens();
+            }
+        });
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+const requestTokens = async (option) => {
+    async function requestMerchantToken(options) {
+        console.log('Requesting Merchant token... \n');
+        options.body['facade'] = 'merchant';
+        let result = await fetch(apiUrl + '/tokens', {
+            method: options.method,
+            headers: options.headers,
+            body: JSON.stringify(options.body)
+        })
+            .then((response) => {
+            return response.json();
+        })
+            .catch((e) => {
+            console.log(e.message);
+        });
+        result = result.data[0];
+        merchantToken = result.token;
+        merchantPairCode = result.pairingCode;
+        await sleep(2000);
+    }
+    async function requestPayoutToken(options) {
+        console.log('Requesting Payout token... \n');
+        options.body['facade'] = 'payout';
+        let result = await fetch(options.url, {
+            method: options.method,
+            headers: options.headers,
+            body: JSON.stringify(options.body)
+        })
+            .then((response) => {
+            return response.json();
+        })
+            .catch((e) => {
+            console.log(e.message);
+        });
+        result = result.data[0];
+        payoutToken = result.token;
+        payoutPairCode = result.pairingCode;
+        await sleep(2000);
+    }
+    try {
+        let reqMerchant = false;
+        let reqPayout = false;
+        switch (option.toLowerCase()) {
+            case 'm':
+                reqMerchant = true;
+                reqPayout = false;
+                break;
+            case 'p':
+                reqMerchant = false;
+                reqPayout = true;
+                break;
+            case 'b':
+                reqMerchant = true;
+                reqPayout = true;
+                break;
+        }
+        const headers = {
+            'x-accept-version': '2.0.0',
+            'Content-type': 'application/json'
+        };
+        const options = {
+            url: apiUrl + '/tokens',
+            method: 'POST',
+            body: { id: keyUtils.get_sin_from_key(ecKey) },
+            headers: headers
+        };
+        if (reqMerchant) {
+            await requestMerchantToken(options);
+        }
+        if (reqPayout) {
+            await requestPayoutToken(options);
+        }
+        await updateConfigFile();
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+const updateConfigFile = async () => {
+    const configurationObject = {
+        BitPayConfiguration: {
+            Environment: environment,
+            EnvConfig: {
+                [environment]: {
+                    PrivateKeyPath: keyPath,
+                    PrivateKey: keyPlain,
+                    ApiTokens: {
+                        merchant: merchantToken,
+                        payout: payoutToken
+                    }
+                }
+            }
+        }
+    };
+    fs.writeFile(ConfFilePath, JSON.stringify(configurationObject, null, 4), function (err) {
+        if (err)
+            throw err;
+        console.log('Generated configuration file');
+        console.log('And saved in file: ' + ConfFilePath + '\n');
+    });
+    await sleep(5000);
+    console.log('Configuration generated successfully! \n');
+    console.log('To complete your setup, Go to ' +
+        apiUrl +
+        '/dashboard/merchant/api-tokens and pair this client with your merchant account using the pairing codes:');
+    if (merchantToken) {
+        console.log(merchantPairCode + ' for the Merchant facade.');
+    }
+    if (payoutToken) {
+        console.log(payoutPairCode + ' for the Payout facade ONLY if you have requested access for this role.');
+    }
+    process.exit();
+};
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+main();
+//# sourceMappingURL=BitPaySetup.js.map

package/dist/util/BitPayResponseParser.d.ts

@@ -0,0 +1,4 @@
+export declare class BitPayResponseParser {
+    getJsonDataFromJsonResponse(responseObj: object): Promise<string | undefined>;
+    static jsonToBoolean(json: string): boolean;
+}