@riocrypto/common 1.0.79 → 1.0.81

package/build/clients/wyre-client.d.ts

@@ -0,0 +1,30 @@
+import { Country } from "../types/country";
+import { Fiat } from "../types/fiat";
+import { PaymentMethod } from "../types/payment-method";
+import { Quote } from "../types/quote";
+import { Side } from "../types/side";
+import { Crypto } from "../types/crypto";
+import { WyreApiGetCardAuthorizationResponse } from "../types/wyre-api-get-card-authorization-response";
+import { WyreApiCreateCardPaymentResponse } from "../types/wyre-api-create-card-payment-response";
+declare class WyreClient {
+    private apiSecret;
+    private environment;
+    private wyreAccountId;
+    constructor(apiSecret: string, environment: "testwyre" | "sendwyre", wyreAccountId: string);
+    setOrderWebhook(accountId: string, webhookUrl: string): Promise<void>;
+    createWalletReservation(amount: string, currency: string, crypto: Crypto, address: string, firstName: string, lastName: string, phone: string, email: string, street1: string, city: string, country: string, postalCode: string, state: string): Promise<any>;
+    createWalletOrder(spreedlyToken: string, amount: string, currency: Fiat, crypto: Crypto, reservationId: string, cryptoAddress: string, firstName: string, lastName: string, email: string, phone: string, street1: string, city: string, state: string, country: string, postalCode: string): Promise<WyreApiCreateCardPaymentResponse>;
+    getAuthorizationCodesCard(wyreOrderId: string): Promise<WyreApiGetCardAuthorizationResponse>;
+    submitAuthorizationCodesCard(type: "SMS" | "CARD2FA" | "ALL", wyreOrderId: string, wyreOrderReservation: string, smsCode: string, card2faCode: string): Promise<{
+        walletOrderId: string;
+        success: boolean;
+    }>;
+    private getBlockchainNetwork;
+    getQuote(side: Side, crypto: Crypto, amount: number, fiat: Fiat, paymentMethod: PaymentMethod, country: Country): Promise<Quote>;
+    getProcessingFeeNumeric(subtotal: number, paymentMethod: PaymentMethod, unitedStates: boolean): number;
+    getTransferFeeNumberic(crypto: Crypto): number;
+    getPlatformFeeRate(): number;
+    getCurrencyConversion(amount: number, from: Fiat, to: Fiat): Promise<Number>;
+}
+export declare const wyreClient: WyreClient;
+export {};

package/build/clients/wyre-client.js

@@ -0,0 +1,246 @@
+"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.wyreClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const country_1 = require("../types/country");
+const fiat_1 = require("../types/fiat");
+const liquidity_provider_1 = require("../types/liquidity-provider");
+const payment_method_1 = require("../types/payment-method");
+const processor_1 = require("../types/processor");
+class WyreClient {
+    constructor(apiSecret, environment, wyreAccountId) {
+        this.apiSecret = apiSecret;
+        this.environment = environment;
+        this.wyreAccountId = wyreAccountId;
+    }
+    setOrderWebhook(accountId, webhookUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, axios_1.default)({
+                method: "post",
+                url: `https://api.${this.environment}.com/v2/digitalwallet/webhook`,
+                headers: {
+                    Authorization: `Bearer ${this.apiSecret}`,
+                },
+                data: {
+                    owner: `account:${accountId}`,
+                    webhook: webhookUrl,
+                },
+            });
+        });
+    }
+    createWalletReservation(amount, currency, crypto, address, firstName, lastName, phone, email, street1, city, country, postalCode, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, axios_1.default)({
+                method: "post",
+                url: `https://api.${this.environment}.com/v3/orders/reserve`,
+                headers: {
+                    Authorization: `Bearer ${this.apiSecret}`,
+                },
+                data: {
+                    amount,
+                    sourceCurrency: currency,
+                    destCurrency: crypto,
+                    dest: `${this.getBlockchainNetwork(crypto)}:${address}`,
+                    firstName,
+                    lastName,
+                    phone,
+                    email,
+                    street1,
+                    city,
+                    state,
+                    country,
+                    postalCode,
+                    referrerAccountId: this.wyreAccountId,
+                },
+            });
+            return response.data;
+        });
+    }
+    createWalletOrder(spreedlyToken, amount, currency, crypto, reservationId, cryptoAddress, firstName, lastName, email, phone, street1, city, state, country, postalCode) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const basicAuth = "Basic " +
+                    Buffer.from(process.env.SPREEDLY_ENV + ":" + process.env.SPREEDLY_SECRET).toString("base64");
+                const response = yield (0, axios_1.default)({
+                    method: "post",
+                    url: `https://core.spreedly.com/v1/receivers/${process.env.SPREEDLY_RECEIVER}/deliver.json`,
+                    headers: {
+                        Authorization: basicAuth,
+                    },
+                    data: {
+                        delivery: {
+                            payment_method_token: spreedlyToken,
+                            url: `https://api.${process.env.WYRE_ENV}.com/v3/debitcard/process/partner`,
+                            headers: `Content-Type: application/json\r\nAuthorization: Bearer ${process.env.WYRE_SECRET}`,
+                            body: JSON.stringify({
+                                amount,
+                                sourceCurrency: currency,
+                                destCurrency: crypto,
+                                reservationId,
+                                referrerAccountId: process.env.WYRE_ACCOUNT_ID,
+                                referenceId: process.env.WYRE_ACCOUNT_ID,
+                                dest: `${this.getBlockchainNetwork(crypto)}:${cryptoAddress}`,
+                                email,
+                                trigger3ds: true,
+                                givenName: firstName,
+                                familyName: lastName,
+                                phone,
+                                address: {
+                                    street1,
+                                    city,
+                                    state,
+                                    postalCode,
+                                    country,
+                                },
+                                debitCard: {
+                                    number: "{{credit_card_number}}",
+                                    year: "{{credit_card_year}}",
+                                    month: "{{credit_card_month}}",
+                                    cvv: "{{credit_card_verification_value}}",
+                                },
+                            }),
+                        },
+                    },
+                });
+                const data = JSON.parse((_c = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.transaction) === null || _b === void 0 ? void 0 : _b.response) === null || _c === void 0 ? void 0 : _c.body);
+                return data;
+            }
+            catch (error) {
+                console.log(error.response.data);
+                throw new Error("Something went wrong");
+            }
+        });
+    }
+    getAuthorizationCodesCard(wyreOrderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, axios_1.default)({
+                method: "get",
+                url: `https://api.${this.environment}.com/v3/debitcard/authorization/${wyreOrderId}`,
+                headers: {
+                    Authorization: `Bearer ${this.apiSecret}`,
+                },
+            });
+            return response.data;
+        });
+    }
+    submitAuthorizationCodesCard(type, wyreOrderId, wyreOrderReservation, smsCode, card2faCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, axios_1.default)({
+                method: "post",
+                url: `https://api.testwyre.com/v3/debitcard/authorize/partner`,
+                headers: {
+                    Authorization: `Bearer ${this.apiSecret}`,
+                },
+                data: {
+                    type,
+                    walletOrderId: wyreOrderId,
+                    reservation: wyreOrderReservation,
+                    sms: smsCode,
+                    card2fa: card2faCode,
+                },
+            });
+            return response.data;
+        });
+    }
+    getBlockchainNetwork(crypto) {
+        if ([
+            "ETH",
+            "USDC",
+            "BAT",
+            "DAI",
+            "MKR",
+            "UNI",
+            "YFI",
+            "AAVE",
+            "COMP",
+            "LINK",
+        ].includes(crypto)) {
+            return "ethereum";
+        }
+        else if (["BTC"].includes(crypto)) {
+            return "bitcoin";
+        }
+        else if (["AVAX"].includes(crypto)) {
+            return "avalanche";
+        }
+        else {
+            return "ethereum";
+        }
+    }
+    getQuote(side, crypto, amount, fiat, paymentMethod, country) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield (0, axios_1.default)({
+                method: "get",
+                url: `https://api.${this.environment}.com/v3/rates`,
+            });
+            const key = `${fiat}${crypto}`;
+            const price = response.data[key];
+            const platformRate = this.getPlatformFeeRate();
+            const processingFeeFiat = this.getProcessingFeeNumeric(amount, paymentMethod, country === country_1.Country.UnitedStates);
+            const platformFeeFiat = platformRate * amount;
+            const TransferFeeFiat = this.getTransferFeeNumberic(crypto);
+            return {
+                price,
+                fees: {
+                    processingFeeFiat,
+                    TransferFeeFiat,
+                    platformFeeFiat,
+                },
+                liquidityProvider: liquidity_provider_1.LiquidityProvider.Wyre,
+                paymentProcessor: processor_1.Processor.Wyre,
+                amountCrypto: (amount - (processingFeeFiat + platformFeeFiat + TransferFeeFiat)) /
+                    price,
+                amountFiat: amount,
+                paymentMethod,
+                crypto,
+                fiat,
+                side,
+            };
+        });
+    }
+    getProcessingFeeNumeric(subtotal, paymentMethod, unitedStates) {
+        switch (paymentMethod) {
+            case payment_method_1.PaymentMethod.Card:
+                if (unitedStates)
+                    return subtotal * 0.029 + 0.3;
+                else
+                    return subtotal * 0.039 + 0.3;
+            default:
+                return subtotal * 0.039 + 0.3;
+        }
+    }
+    getTransferFeeNumberic(crypto) {
+        return 3;
+    }
+    getPlatformFeeRate() {
+        return 0.001;
+    }
+    getCurrencyConversion(amount, from, to) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (from === fiat_1.Fiat.USD) {
+                return amount;
+            }
+            const response = yield (0, axios_1.default)({
+                method: "get",
+                url: `https://api.${this.environment}.com/v3/rates`,
+            });
+            const key = `${from}${to}`;
+            const conversionRate = response.data[key];
+            return amount / conversionRate;
+        });
+    }
+}
+exports.wyreClient = new WyreClient(process.env.WYRE_SECRET, process.env.WYRE_ENV, process.env.WYRE_ACCOUNT_ID);

package/build/index.d.ts

@@ -49,3 +49,4 @@ export * from "./types/user-update";
 export * from "./types/wyre-api-create-card-payment-response";
 export * from "./types/wyre-webhook-notification";
 export * from "./types/wyre-api-get-card-authorization-response";
+export * from "./clients/wyre-client";

package/build/index.js

@@ -65,3 +65,4 @@ __exportStar(require("./types/user-update"), exports);
 __exportStar(require("./types/wyre-api-create-card-payment-response"), exports);
 __exportStar(require("./types/wyre-webhook-notification"), exports);
 __exportStar(require("./types/wyre-api-get-card-authorization-response"), exports);
+__exportStar(require("./clients/wyre-client"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common",
-  "version": "1.0.79",
+  "version": "1.0.81",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -21,6 +21,7 @@
   },
   "dependencies": {
     "@types/express": "^4.17.13",
+    "axios": "^0.27.2",
     "express": "^4.18.1",
     "express-validator": "^6.14.2",
     "jsonwebtoken": "^8.5.1",