@houlak/plexo-sdk 0.1.1-rc.1 → 0.1.2-h

package/lib/handler/PlexoHandler.d.ts

@@ -1,21 +1,31 @@
-import { Authorization, BaseServerResponse, CancelRequest, ClientSignedResponse, Commerce, CommerceIdRequest, CommerceIssuerIdRequest, CommerceRequest, DeleteInstrumentRequest, ExpressCheckoutRequest, InstrumentCallback, IssuerData, IssuerInfo, IssuerProcessor, PaymentRequest, ServerResponse, ServerSignedCallback, Session, Transaction, TransactionCallback } from '../sdk/index';
+import { Authorization, AuthorizationInfo, BaseServerResponse, CancelRequest, ClientSignedResponse, CodeRequest, Commerce, CommerceIdRequest, CommerceIssuerIdRequest, CommerceModifyRequest, CommerceRequest, CreateBankInstrumentRequest, DeleteInstrumentRequest, ExpressCheckoutRequest, InstrumentCallback, IssuerData, IssuerInfo, IssuerProcessor, PaymentInstrument, PaymentRequest, Reference, Reserve, ReserveRequest, ServerResponse, Session, Transaction, TransactionCallback, TransactionCursor, TransactionQuery, TransactionsCSV } from '../sdk/index';
 import { BaseResponse } from './types/BaseResponse';
 export declare const PlexoHandler: {
     AddCommerce: (commerceRequest: CommerceRequest) => Promise<BaseResponse<Commerce>>;
     AddIssuerCommerce: (issuerData: IssuerData) => Promise<BaseResponse<IssuerData>>;
-    GetCommerceIssuers: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<IssuerData[]>>;
-    GetCommerces: () => Promise<BaseResponse<Commerce[]>>;
     DeleteCommerce: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
-    DeleteIssuerCommerce: (commerceIssuerIdRequest: CommerceIssuerIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
     DeleteInstrument: (instrument: DeleteInstrumentRequest) => Promise<BaseResponse<BaseServerResponse>>;
+    DeleteIssuerCommerce: (commerceIssuerIdRequest: CommerceIssuerIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
+    GetCommerceIssuers: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<IssuerData[]>>;
+    GetCommerces: () => Promise<BaseResponse<Commerce[]>>;
     GetSupportedIssuers: () => Promise<BaseResponse<IssuerInfo[]>>;
     GetSupportedPaymentProcessors: () => Promise<BaseResponse<IssuerProcessor[]>>;
+    ModifyCommerce: (commerceModifyRequest: CommerceModifyRequest) => Promise<BaseResponse<Commerce>>;
+    GetInstruments: (authorizationInfo: AuthorizationInfo) => Promise<BaseResponse<PaymentInstrument[]>>;
+    SetDefaultCommerce: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
     Authorize: (authorization: Authorization) => Promise<BaseResponse<Session>>;
     Cancel: (cancellation: CancelRequest) => Promise<BaseResponse<Transaction>>;
+    CodeAction: (request: CodeRequest) => Promise<BaseResponse<Transaction>>;
+    StartReserve: (payment: ReserveRequest) => Promise<BaseResponse<Transaction>>;
+    Status: (payment: Reference) => Promise<BaseResponse<Transaction>>;
     ExpressCheckout: (expressCheckout: ExpressCheckoutRequest) => Promise<BaseResponse<Session>>;
+    ObtainCsvTransactions: (query: TransactionQuery) => Promise<BaseResponse<TransactionsCSV>>;
+    ObtainTransactions: (query: TransactionQuery) => Promise<BaseResponse<TransactionCursor>>;
     Purchase: (purchase: PaymentRequest) => Promise<BaseResponse<Transaction>>;
-    UnwrapInstrumentCallback: (instrumentCallback: ServerSignedCallback<InstrumentCallback>) => Promise<BaseResponse<InstrumentCallback>>;
-    UnwrapTransactionCallback: (transactionCallback: ServerSignedCallback<TransactionCallback>) => Promise<BaseResponse<TransactionCallback>>;
+    CreateBankInstrument: (request: CreateBankInstrumentRequest) => Promise<BaseResponse<PaymentInstrument>>;
+    EndReserve: (reserve: Reserve) => Promise<BaseResponse<Transaction>>;
+    UnwrapInstrumentCallback: (instrumentCallback: any) => Promise<BaseResponse<InstrumentCallback>>;
+    UnwrapTransactionCallback: (transactionCallback: any) => Promise<BaseResponse<TransactionCallback>>;
     SignInstrumentCallback: (instrumentCallback: ServerResponse<InstrumentCallback>) => Promise<BaseResponse<ClientSignedResponse>>;
-    SignTransactionCallback: (transactionCallback: ServerResponse<TransactionCallback>) => Promise<BaseResponse<ClientSignedResponse>>;
+    SignTransactionCallback: (transactionCallback: any) => Promise<BaseResponse<ClientSignedResponse>>;
 };

package/lib/handler/PlexoHandler.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -41,6 +52,7 @@ var index_1 = require("../sdk/index");
 var evaluator_service_1 = require("./services/evaluator.service");
 var config_1 = require("../config/config");
 var PaymentGatewayMock_1 = require("../sdk/PaymentGatewayMock");
+var utils_1 = require("../utils");
 var isTesting = config_1.config.env === 'TEST';
 var paymentGatewayClient = isTesting
     ? new PaymentGatewayMock_1.PaymentGatewayMock()
@@ -156,6 +168,43 @@ var GetSupportedPaymentProcessors = function () { return __awaiter(void 0, void
         }
     });
 }); };
+var ModifyCommerce = function (commerceModifyRequest) { return __awaiter(void 0, void 0, void 0, function () {
+    var modifyCommerceResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.ModifyCommerceAsync(commerceModifyRequest)];
+            case 1:
+                modifyCommerceResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceModifyRequest, modifyCommerceResponse)];
+        }
+    });
+}); };
+var GetInstruments = function (authorizationInfo) { return __awaiter(void 0, void 0, void 0, function () {
+    var instrumentsResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.GetInstrumentsAsync(authorizationInfo)];
+            case 1:
+                instrumentsResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(authorizationInfo, instrumentsResponse)];
+        }
+    });
+}); };
+var SetDefaultCommerce = function (commerceIdRequest) { return __awaiter(void 0, void 0, void 0, function () {
+    var setDefaultCommerceResponse, wrappedResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.SetDefaultCommerceAsync(commerceIdRequest)];
+            case 1:
+                setDefaultCommerceResponse = _a.sent();
+                wrappedResponse = {
+                    response: setDefaultCommerceResponse,
+                    resultCode: setDefaultCommerceResponse.resultCode,
+                };
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceIdRequest, wrappedResponse)];
+        }
+    });
+}); };
 var Authorize = function (authorization) { return __awaiter(void 0, void 0, void 0, function () {
     var authorizationResponse;
     return __generator(this, function (_a) {
@@ -179,6 +228,39 @@ var Cancel = function (cancellation) { return __awaiter(void 0, void 0, void 0,
         }
     });
 }); };
+var CodeAction = function (request) { return __awaiter(void 0, void 0, void 0, function () {
+    var codeActionResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.CodeActionAsync(request)];
+            case 1:
+                codeActionResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(request, codeActionResponse)];
+        }
+    });
+}); };
+var StartReserve = function (payment) { return __awaiter(void 0, void 0, void 0, function () {
+    var reserveResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.StartReserveAsync(payment)];
+            case 1:
+                reserveResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(payment, reserveResponse, 'Reserve', index_1.TransactionType.Reserve)];
+        }
+    });
+}); };
+var Status = function (payment) { return __awaiter(void 0, void 0, void 0, function () {
+    var statusResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.StatusAsync(payment)];
+            case 1:
+                statusResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(payment, statusResponse)];
+        }
+    });
+}); };
 var ExpressCheckout = function (expressCheckout) { return __awaiter(void 0, void 0, void 0, function () {
     var expressCheckoutResponse;
     return __generator(this, function (_a) {
@@ -190,6 +272,31 @@ var ExpressCheckout = function (expressCheckout) { return __awaiter(void 0, void
         }
     });
 }); };
+var ObtainCsvTransactions = function (query) { return __awaiter(void 0, void 0, void 0, function () {
+    var csvTransactionsStringResponse, csvTransactionsResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.ObtainCsvTransactionsAsync(query)];
+            case 1:
+                csvTransactionsStringResponse = _a.sent();
+                csvTransactionsResponse = __assign(__assign({}, csvTransactionsStringResponse), { response: {
+                        csv: csvTransactionsStringResponse.response,
+                    } });
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(query, csvTransactionsResponse)];
+        }
+    });
+}); };
+var ObtainTransactions = function (query) { return __awaiter(void 0, void 0, void 0, function () {
+    var transactionsResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.ObtainTransactionsAsync(query)];
+            case 1:
+                transactionsResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(query, transactionsResponse)];
+        }
+    });
+}); };
 var Purchase = function (purchase) { return __awaiter(void 0, void 0, void 0, function () {
     var purchaseResponse;
     return __generator(this, function (_a) {
@@ -201,11 +308,35 @@ var Purchase = function (purchase) { return __awaiter(void 0, void 0, void 0, fu
         }
     });
 }); };
+var CreateBankInstrument = function (request) { return __awaiter(void 0, void 0, void 0, function () {
+    var bankInstrumentResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.CreateBankInstrumentAsync(request)];
+            case 1:
+                bankInstrumentResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(request, bankInstrumentResponse)];
+        }
+    });
+}); };
+var EndReserve = function (reserve) { return __awaiter(void 0, void 0, void 0, function () {
+    var endReserveResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.EndReserveAsync(reserve)];
+            case 1:
+                endReserveResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(reserve, endReserveResponse, 'Reserve', index_1.TransactionType.Reserve)];
+        }
+    });
+}); };
 var UnwrapInstrumentCallback = function (instrumentCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var instrumentCallbackResponse;
+    var instrumentCallbackCamelCase, instrumentCallbackResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.UnwrapInstrumentCallbackAsync(instrumentCallback)];
+            case 0:
+                instrumentCallbackCamelCase = utils_1.caseUtils.toCamelKeys(instrumentCallback);
+                return [4 /*yield*/, paymentGatewayClient.UnwrapInstrumentCallbackAsync(instrumentCallbackCamelCase)];
             case 1:
                 instrumentCallbackResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(instrumentCallback, instrumentCallbackResponse)];
@@ -213,10 +344,12 @@ var UnwrapInstrumentCallback = function (instrumentCallback) { return __awaiter(
     });
 }); };
 var UnwrapTransactionCallback = function (transactionCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var transactionCallbackResponse;
+    var transactionCallbackCamelCase, transactionCallbackResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.UnwrapTransactionCallbackAsync(transactionCallback)];
+            case 0:
+                transactionCallbackCamelCase = utils_1.caseUtils.toCamelKeys(transactionCallback);
+                return [4 /*yield*/, paymentGatewayClient.UnwrapTransactionCallbackAsync(transactionCallbackCamelCase)];
             case 1:
                 transactionCallbackResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(transactionCallback, transactionCallbackResponse)];
@@ -224,41 +357,63 @@ var UnwrapTransactionCallback = function (transactionCallback) { return __awaite
     });
 }); };
 var SignInstrumentCallback = function (instrumentCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var signInstrumentCallbackResponse;
+    var signInstrumentCallbackResponse, serverResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0: return [4 /*yield*/, paymentGatewayClient.SignInstrumentCallback(instrumentCallback)];
             case 1:
                 signInstrumentCallbackResponse = _a.sent();
-                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(instrumentCallback, signInstrumentCallbackResponse)];
+                serverResponse = {
+                    response: signInstrumentCallbackResponse,
+                    resultCode: signInstrumentCallbackResponse.object.object.resultCode,
+                    errorMessage: signInstrumentCallbackResponse.object.object.errorMessage,
+                    i18ErrorMessages: signInstrumentCallbackResponse.object.object.i18ErrorMessages,
+                };
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(instrumentCallback, serverResponse)];
         }
     });
 }); };
 var SignTransactionCallback = function (transactionCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var signTransactionCallbackResponse;
+    var signTransactionCallbackResponse, serverResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0: return [4 /*yield*/, paymentGatewayClient.SignTransactionCallback(transactionCallback)];
             case 1:
                 signTransactionCallbackResponse = _a.sent();
-                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(transactionCallback, signTransactionCallbackResponse)];
+                serverResponse = {
+                    response: signTransactionCallbackResponse,
+                    resultCode: signTransactionCallbackResponse.object.object.resultCode,
+                    errorMessage: signTransactionCallbackResponse.object.object.errorMessage,
+                    i18ErrorMessages: signTransactionCallbackResponse.object.object.i18ErrorMessages,
+                };
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(transactionCallback, serverResponse)];
         }
     });
 }); };
 exports.PlexoHandler = {
     AddCommerce: AddCommerce,
     AddIssuerCommerce: AddIssuerCommerce,
-    GetCommerceIssuers: GetCommerceIssuers,
-    GetCommerces: GetCommerces,
     DeleteCommerce: DeleteCommerce,
-    DeleteIssuerCommerce: DeleteIssuerCommerce,
     DeleteInstrument: DeleteInstrument,
+    DeleteIssuerCommerce: DeleteIssuerCommerce,
+    GetCommerceIssuers: GetCommerceIssuers,
+    GetCommerces: GetCommerces,
     GetSupportedIssuers: GetSupportedIssuers,
     GetSupportedPaymentProcessors: GetSupportedPaymentProcessors,
+    ModifyCommerce: ModifyCommerce,
+    GetInstruments: GetInstruments,
+    SetDefaultCommerce: SetDefaultCommerce,
     Authorize: Authorize,
     Cancel: Cancel,
+    CodeAction: CodeAction,
+    StartReserve: StartReserve,
+    Status: Status,
     ExpressCheckout: ExpressCheckout,
+    ObtainCsvTransactions: ObtainCsvTransactions,
+    ObtainTransactions: ObtainTransactions,
     Purchase: Purchase,
+    CreateBankInstrument: CreateBankInstrument,
+    EndReserve: EndReserve,
     UnwrapInstrumentCallback: UnwrapInstrumentCallback,
     UnwrapTransactionCallback: UnwrapTransactionCallback,
     SignInstrumentCallback: SignInstrumentCallback,

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export { PlexoHandler } from './handler/PlexoHandler';
 export * as ModelsSDK from './sdk/models/IndexSDK';
+export * as ModelsAPI from './sdk/models/webhook';

package/lib/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelsSDK = exports.PlexoHandler = void 0;
+exports.ModelsAPI = exports.ModelsSDK = exports.PlexoHandler = void 0;
 var PlexoHandler_1 = require("./handler/PlexoHandler");
 Object.defineProperty(exports, "PlexoHandler", { enumerable: true, get: function () { return PlexoHandler_1.PlexoHandler; } });
+// Model for transaction callback (WS Service)
 exports.ModelsSDK = require("./sdk/models/IndexSDK");
+// Model for plexo webhook (API)
+exports.ModelsAPI = require("./sdk/models/webhook");

package/lib/lib/logger.lib.d.ts

@@ -2,12 +2,7 @@ declare const logger: import("pino").Logger<{
     level: string;
     base: null;
     nestedKey: string;
-    transport: {
-        target: string;
-        options: {
-            colorize: boolean;
-        };
-    };
+    transport: any;
     serializers: {
         data: (data: any | Error) => any;
     };

package/lib/lib/logger.lib.js

@@ -2,16 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var pino_1 = require("pino");
 var config_1 = require("../config/config");
+var transport = null;
+if (['LOCAL', 'TEST'].includes(config_1.config.env)) {
+    transport = {
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+        },
+    };
+}
 var logger = (0, pino_1.default)({
     level: config_1.config.logger.level,
     base: null,
     nestedKey: 'data',
-    transport: {
-        target: 'pino-pretty',
-        options: {
-            colorize: config_1.config.env === 'LOCAL' ? true : false,
-        },
-    },
+    transport: transport,
     serializers: {
         // Needed because errors don't get serialized when using nestedKey
         /* eslint-disable */

package/lib/sdk/IPaymentGatewayClient.d.ts

@@ -26,6 +26,6 @@ export interface IPaymentGatewayClient {
     EndReserveAsync(reserve: Reserve): Promise<ServerResponse<Transaction>>;
     UnwrapInstrumentCallbackAsync(serverSignedInstrumentCallback: ServerSignedCallback<InstrumentCallback>): Promise<ServerResponse<InstrumentCallback>>;
     UnwrapTransactionCallbackAsync(serverSignedTransactionCallback: ServerSignedCallback<TransactionCallback>): Promise<ServerResponse<TransactionCallback>>;
-    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>): Promise<ServerResponse<ClientSignedResponse>>;
-    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>): Promise<ServerResponse<ClientSignedResponse>>;
+    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>): Promise<ClientSignedResponse>;
+    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>): Promise<ClientSignedResponse>;
 }

package/lib/sdk/PaymentGatewayClient.d.ts

@@ -27,6 +27,6 @@ export declare class PaymentGatewayClient implements IPaymentGatewayClient {
     EndReserveAsync(reserve: Reserve): Promise<ServerResponse<Transaction>>;
     UnwrapInstrumentCallbackAsync(serverSignedInstrumentCallback: ServerSignedCallback<InstrumentCallback>): Promise<ServerResponse<InstrumentCallback>>;
     UnwrapTransactionCallbackAsync(serverSignedTransactionCallback: ServerSignedCallback<TransactionCallback>): Promise<ServerResponse<TransactionCallback>>;
-    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>): Promise<ServerResponse<ClientSignedResponse>>;
-    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>): Promise<ServerResponse<ClientSignedResponse>>;
+    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>): Promise<ClientSignedResponse>;
+    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>): Promise<ClientSignedResponse>;
 }

package/lib/sdk/PaymentGatewayClient.js

@@ -52,6 +52,7 @@ var axios_1 = require("axios");
 var logger_lib_1 = require("../lib/logger.lib");
 var config_1 = require("../config/config");
 var signatureHelper_1 = require("./helpers/signature/signatureHelper");
+var utils_1 = require("../utils");
 var client = axios_1.default.create({
     baseURL: config_1.config.plexoUrl,
 });
@@ -70,16 +71,16 @@ var requestToPlexo = function (endpoint, request) { return __awaiter(void 0, voi
                     utcUnixTimeExpiration: Date.parse(new Date().toString()),
                     object: object,
                 };
-                return [4 /*yield*/, signatureHelper_1.SignatureHelper.getSignatureFromPlexo(stateObject)];
+                return [4 /*yield*/, signatureHelper_1.SignatureHelper.signRequest(stateObject)];
             case 1:
                 signedClientRequest = _a.sent();
-                logger_lib_1.default.debug("URL PX --> ".concat(endpoint));
-                logger_lib_1.default.debug("SIGNED CLIENT REQUEST --> ".concat(JSON.stringify(signedClientRequest)));
+                logger_lib_1.default.debug("URL PX: ".concat(endpoint));
+                logger_lib_1.default.debug(signedClientRequest, 'Signed client request');
                 return [4 /*yield*/, client.post(endpoint, __assign({}, signedClientRequest))];
             case 2:
                 data = (_a.sent()).data;
                 logger_lib_1.default.debug({ data: data });
-                return [2 /*return*/, signatureHelper_1.SignatureHelper.toCamelKeys(data.Object.Object)];
+                return [2 /*return*/, utils_1.caseUtils.toCamelKeys(data.Object.Object)];
             case 3:
                 err_1 = _a.sent();
                 logger_lib_1.default.error({ err: err_1 });
@@ -326,7 +327,7 @@ var PaymentGatewayClient = /** @class */ (function () {
             var verify;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.getPlexoSignature(serverSignedInstrumentCallback.object.fingerprint, serverSignedInstrumentCallback)];
+                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.unwrapCallback(serverSignedInstrumentCallback.object.fingerprint, serverSignedInstrumentCallback)];
                     case 1:
                         verify = _a.sent();
                         return [2 /*return*/, verify];
@@ -339,7 +340,7 @@ var PaymentGatewayClient = /** @class */ (function () {
             var verify;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.getPlexoSignature(serverSignedTransactionCallback.object.fingerprint, serverSignedTransactionCallback)];
+                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.unwrapCallback(serverSignedTransactionCallback.object.fingerprint, serverSignedTransactionCallback)];
                     case 1:
                         verify = _a.sent();
                         return [2 /*return*/, verify];
@@ -352,7 +353,7 @@ var PaymentGatewayClient = /** @class */ (function () {
             var response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.getSignatureFromCallback(serverResponse)];
+                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.signCallback(serverResponse)];
                     case 1:
                         response = _a.sent();
                         return [2 /*return*/, response];
@@ -365,7 +366,7 @@ var PaymentGatewayClient = /** @class */ (function () {
             var response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.getSignatureFromCallback(serverResponse)];
+                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.signCallback(serverResponse)];
                     case 1:
                         response = _a.sent();
                         return [2 /*return*/, response];

package/lib/sdk/PaymentGatewayMock.d.ts

@@ -26,6 +26,6 @@ export declare class PaymentGatewayMock implements IPaymentGatewayClient {
     EndReserveAsync(reserve: Reserve): Promise<ServerResponse<Transaction>>;
     UnwrapInstrumentCallbackAsync(serverSignedInstrumentCallback: ServerSignedCallback<InstrumentCallback>): Promise<ServerResponse<InstrumentCallback>>;
     UnwrapTransactionCallbackAsync(serverSignedTransactionCallback: ServerSignedCallback<TransactionCallback>): Promise<ServerResponse<TransactionCallback>>;
-    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>): Promise<ServerResponse<ClientSignedResponse>>;
-    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>): Promise<ServerResponse<ClientSignedResponse>>;
+    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>): Promise<ClientSignedResponse>;
+    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>): Promise<ClientSignedResponse>;
 }

package/lib/sdk/PaymentGatewayMock.js

@@ -314,20 +314,14 @@ var PaymentGatewayMock = /** @class */ (function () {
     PaymentGatewayMock.prototype.SignInstrumentCallback = function (serverResponse) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, {
-                        resultCode: IndexSDK_1.ResultCodes.Ok,
-                        response: mocks_1.mocks.clientSignedResponseMock,
-                    }];
+                return [2 /*return*/, mocks_1.mocks.clientSignedResponseMock];
             });
         });
     };
     PaymentGatewayMock.prototype.SignTransactionCallback = function (serverResponse) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, {
-                        resultCode: IndexSDK_1.ResultCodes.Ok,
-                        response: mocks_1.mocks.clientSignedResponseMock,
-                    }];
+                return [2 /*return*/, mocks_1.mocks.clientSignedResponseMock];
             });
         });
     };

package/lib/sdk/enums/plexo-error-enum.d.ts

@@ -1,4 +1,5 @@
 export declare enum PlexoErrorEnum {
+    CommerceAlreadyExists = 25,
     ExceptionHandlingTransaction = 1200,
     PlexoAuthorizationError = 1201,
     InstrumentNotFound = 1202,

package/lib/sdk/enums/plexo-error-enum.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlexoErrorEnum = void 0;
 var PlexoErrorEnum;
 (function (PlexoErrorEnum) {
+    PlexoErrorEnum[PlexoErrorEnum["CommerceAlreadyExists"] = 25] = "CommerceAlreadyExists";
     PlexoErrorEnum[PlexoErrorEnum["ExceptionHandlingTransaction"] = 1200] = "ExceptionHandlingTransaction";
     PlexoErrorEnum[PlexoErrorEnum["PlexoAuthorizationError"] = 1201] = "PlexoAuthorizationError";
     PlexoErrorEnum[PlexoErrorEnum["InstrumentNotFound"] = 1202] = "InstrumentNotFound";

package/lib/sdk/helpers/signature/signatureHelper.d.ts

@@ -1,10 +1,6 @@
 import { ClientSignedResponse, GenericSignedObject, GenericStateObject, InstrumentCallback, ServerResponse, TransactionCallback } from '../..';
-import { Certificate } from '../../types/signatureHelper.type';
-export declare const canonizeJson: <T>(object: T) => T;
 export declare const SignatureHelper: {
-    getCertificate: () => Promise<Certificate>;
-    getSignatureFromPlexo: <T extends object>(objectToSign: GenericStateObject<T>) => Promise<GenericSignedObject<T>>;
-    getSignatureFromCallback: (response: ServerResponse<InstrumentCallback | TransactionCallback>) => Promise<ServerResponse<ClientSignedResponse>>;
-    getPlexoSignature: <T_1 extends object>(fingerprint: string, response: GenericSignedObject<T_1>) => Promise<ServerResponse<T_1>>;
-    toCamelKeys: <T_2 extends object>(object: T_2) => T_2;
+    signRequest: <T extends object>(objectToSign: GenericStateObject<T>) => Promise<GenericSignedObject<T>>;
+    unwrapCallback: <T_1 extends object>(fingerprint: string, response: GenericSignedObject<T_1>) => Promise<ServerResponse<T_1>>;
+    signCallback: (response: ServerResponse<InstrumentCallback | TransactionCallback>) => Promise<ClientSignedResponse>;
 };