@houlak/plexo-sdk 0.1.9 → 0.1.10-fx

package/lib/sdk/PaymentGatewayClient.js

@@ -50,19 +50,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaymentGatewayClient = void 0;
 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,
+    baseURL: "https://testing.plexo.com.uy:4043/SecurePaymentGateway.svc",
 });
-var requestToPlexo = function (endpoint, request) { return __awaiter(void 0, void 0, void 0, function () {
+var requestToPlexo = function (endpoint, request, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var object, stateObject, signedClientRequest, data, err_1;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 _a.trys.push([0, 3, , 4]);
                 object = {
-                    client: config_1.config.plexoClient.clientName,
+                    client: fixedCustomData.plexoClientName,
                     request: request,
                 };
                 stateObject = {
@@ -70,16 +70,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, fixedCustomData.plexoCertificatePassword, fixedCustomData.plexoCertificatePath)];
             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 });
@@ -91,242 +91,323 @@ var requestToPlexo = function (endpoint, request) { return __awaiter(void 0, voi
 var PaymentGatewayClient = /** @class */ (function () {
     function PaymentGatewayClient() {
     }
-    PaymentGatewayClient.prototype.AddCommerceAsync = function (commerce) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Add', commerce)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
     PaymentGatewayClient.prototype.AddIssuerCommerceAsync = function (issuerData) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer/Add', issuerData)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.DeleteCommerceAsync = function (commerceIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Delete', commerceIdRequest)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.DeleteInstrumentAsync = function (info) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Instruments/Delete', info)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.DeleteIssuerCommerceAsync = function (commerceIssuerIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer/Delete', commerceIssuerIdRequest)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.GetCommerceIssuersAsync = function (commerceIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer', commerceIdRequest)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
-    PaymentGatewayClient.prototype.GetCommercesAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce', '')];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+    PaymentGatewayClient.prototype.GetCommercesAsync = function (fixedCustomData) {
+        throw new Error('Method not implemented.');
     };
-    PaymentGatewayClient.prototype.GetSupportedIssuersAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Issuer', '')];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+    PaymentGatewayClient.prototype.GetSupportedIssuersAsync = function (fixedCustomData) {
+        throw new Error('Method not implemented.');
     };
-    PaymentGatewayClient.prototype.GetSupportedPaymentProcessorsAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/PaymentProcessors', '')];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+    PaymentGatewayClient.prototype.GetSupportedPaymentProcessorsAsync = function (fixedCustomData) {
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.ModifyCommerceAsync = function (commerceModifyRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Modify', commerceModifyRequest)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.GetInstrumentsAsync = function (authorizationInfo) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Instruments', authorizationInfo)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.SetDefaultCommerceAsync = function (commerceIdRequest) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/SetDefault', commerceIdRequest)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.AuthorizeAsync = function (authorization) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Auth', authorization)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.CancelAsync = function (cancel) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/Cancel', cancel)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.CodeActionAsync = function (request) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Code', request)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.StartReserveAsync = function (payment) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/StartReserve', payment)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.StatusAsync = function (payment) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/Status', payment)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    PaymentGatewayClient.prototype.ExpressCheckoutAsync = function (expressCheckout) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', expressCheckout)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.ObtainCsvTransactionsAsync = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', query)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.ObtainTransactionsAsync = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Transactions', query)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.PurchaseAsync = function (payment) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/Purchase', payment)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
+        throw new Error('Method not implemented.');
     };
     PaymentGatewayClient.prototype.CreateBankInstrumentAsync = function (request) {
+        throw new Error('Method not implemented.');
+    };
+    PaymentGatewayClient.prototype.EndReserveAsync = function (reserve) {
+        throw new Error('Method not implemented.');
+    };
+    PaymentGatewayClient.prototype.AddCommerceAsync = function (commerce, fixedCustomData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Instruments/Bank', request)];
+                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Add', commerce, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.EndReserveAsync = function (reserve) {
+    /*async AddIssuerCommerceAsync(issuerData: IssuerData): Promise<ServerResponse<IssuerData>> {
+      return await requestToPlexo<IssuerData, ServerResponse<IssuerData>>(
+        '/Commerce/Issuer/Add',
+        issuerData,
+        issuerData.plexoClientName,
+        issuerData.plexoCertificatePassword,
+        issuerData.plexoCertificatePath,
+      )
+    }
+  
+    async DeleteCommerceAsync(
+      commerceIdRequest: CommerceIdRequest,
+    ): Promise<ServerResponse<BaseServerResponse>> {
+      return await requestToPlexo<CommerceIdRequest, ServerResponse<BaseServerResponse>>(
+        '/Commerce/Delete',
+        commerceIdRequest,
+        commerceIdRequest.plexoClientName,
+        commerceIdRequest.plexoCertificatePassword,
+        commerceIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async DeleteInstrumentAsync(
+      info: DeleteInstrumentRequest,
+    ): Promise<ServerResponse<BaseServerResponse>> {
+      return await requestToPlexo<DeleteInstrumentRequest, ServerResponse<BaseServerResponse>>(
+        '/Instruments/Delete',
+        info,
+        info.plexoClientName,
+        info.plexoCertificatePassword,
+        info.plexoCertificatePath,
+      )
+    }
+  
+    async DeleteIssuerCommerceAsync(
+      commerceIssuerIdRequest: CommerceIssuerIdRequest,
+    ): Promise<ServerResponse<BaseServerResponse>> {
+      return await requestToPlexo<CommerceIssuerIdRequest, ServerResponse<BaseServerResponse>>(
+        '/Commerce/Issuer/Delete',
+        commerceIssuerIdRequest,
+        commerceIssuerIdRequest.plexoClientName,
+        commerceIssuerIdRequest.plexoCertificatePassword,
+        commerceIssuerIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async GetCommerceIssuersAsync(
+      commerceIdRequest: CommerceIdRequest,
+    ): Promise<ServerResponse<IssuerData[]>> {
+      return await requestToPlexo<CommerceIdRequest, ServerResponse<IssuerData[]>>(
+        '/Commerce/Issuer',
+        commerceIdRequest,
+        commerceIdRequest.plexoClientName,
+        commerceIdRequest.plexoCertificatePassword,
+        commerceIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async GetCommercesAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce[]>> {
+      return await requestToPlexo<string, ServerResponse<Commerce[]>>(
+        '/Commerce',
+        '',
+        fixedCustomData.plexoClientName,
+        fixedCustomData.plexoCertificatePassword,
+        fixedCustomData.plexoCertificatePath,
+      )
+    }
+  
+    async GetSupportedIssuersAsync(
+      fixedCustomData: FixedCustomData,
+    ): Promise<ServerResponse<IssuerInfo[]>> {
+      return await requestToPlexo<string, ServerResponse<IssuerInfo[]>>(
+        '/Issuer',
+        '',
+        fixedCustomData.plexoClientName,
+        fixedCustomData.plexoCertificatePassword,
+        fixedCustomData.plexoCertificatePath,
+      )
+    }
+  
+    async GetSupportedPaymentProcessorsAsync(
+      fixedCustomData: FixedCustomData,
+    ): Promise<ServerResponse<IssuerProcessor[]>> {
+      return await requestToPlexo<string, ServerResponse<IssuerProcessor[]>>(
+        '/PaymentProcessors',
+        '',
+        fixedCustomData.plexoClientName,
+        fixedCustomData.plexoCertificatePassword,
+        fixedCustomData.plexoCertificatePath,
+      )
+    }
+  
+    async ModifyCommerceAsync(
+      commerceModifyRequest: CommerceModifyRequest,
+    ): Promise<ServerResponse<Commerce>> {
+      return await requestToPlexo<CommerceModifyRequest, ServerResponse<Commerce>>(
+        '/Commerce/Modify',
+        commerceModifyRequest,
+        commerceModifyRequest.plexoClientName,
+        commerceModifyRequest.plexoCertificatePassword,
+        commerceModifyRequest.plexoCertificatePath,
+      )
+    }
+  
+    async GetInstrumentsAsync(
+      authorizationInfo: AuthorizationInfo,
+    ): Promise<ServerResponse<PaymentInstrument[]>> {
+      return await requestToPlexo<AuthorizationInfo, ServerResponse<PaymentInstrument[]>>(
+        '/Instruments',
+        authorizationInfo,
+        authorizationInfo.plexoClientName,
+        authorizationInfo.plexoCertificatePassword,
+        authorizationInfo.plexoCertificatePath,
+      )
+    }
+  
+    async SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse> {
+      return await requestToPlexo<CommerceIdRequest, BaseServerResponse>(
+        '/Commerce/SetDefault',
+        commerceIdRequest,
+        commerceIdRequest.plexoClientName,
+        commerceIdRequest.plexoCertificatePassword,
+        commerceIdRequest.plexoCertificatePath,
+      )
+    }
+  
+    async AuthorizeAsync(authorization: Authorization): Promise<ServerResponse<Session>> {
+      return await requestToPlexo<Authorization, ServerResponse<Session>>(
+        '/Auth',
+        authorization,
+        authorization.plexoClientName,
+        authorization.plexoCertificatePassword,
+        authorization.plexoCertificatePath,
+      )
+    }
+  
+    async CancelAsync(cancel: CancelRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<CancelRequest, ServerResponse<Transaction>>(
+        '/Operation/Cancel',
+        cancel,
+        cancel.plexoClientName,
+        cancel.plexoCertificatePassword,
+        cancel.plexoCertificatePath,
+      )
+    }
+  
+    async CodeActionAsync(request: CodeRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<CodeRequest, ServerResponse<Transaction>>(
+        '/Code',
+        request,
+        request.plexoClientName,
+        request.plexoCertificatePassword,
+        request.plexoCertificatePath,
+      )
+    }
+  
+    async StartReserveAsync(payment: ReserveRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<ReserveRequest, ServerResponse<Transaction>>(
+        '/Operation/StartReserve',
+        payment,
+        payment.plexoClientName,
+        payment.plexoCertificatePassword,
+        payment.plexoCertificatePath,
+      )
+    }
+  
+    async StatusAsync(payment: Reference): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<Reference, ServerResponse<Transaction>>(
+        '/Operation/Status',
+        payment,
+        payment.plexoClientName,
+        payment.plexoCertificatePassword,
+        payment.plexoCertificatePath,
+      )
+    }*/
+    PaymentGatewayClient.prototype.ExpressCheckoutAsync = function (expressCheckout, fixedCustomData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Operation/EndReserve', reserve)];
+                    case 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', expressCheckout, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.UnwrapInstrumentCallbackAsync = function (serverSignedInstrumentCallback) {
+    /*async ObtainCsvTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<string>> {
+      return await requestToPlexo<TransactionQuery, ServerResponse<string>>(
+        '/ExpressCheckout',
+        query,
+        query.plexoClientName,
+        query.plexoCertificatePassword,
+        query.plexoCertificatePath,
+      )
+    }
+  
+    async ObtainTransactionsAsync(
+      query: TransactionQuery,
+    ): Promise<ServerResponse<TransactionCursor>> {
+      return await requestToPlexo<TransactionQuery, ServerResponse<TransactionCursor>>(
+        '/Transactions',
+        query,
+        query.plexoClientName,
+        query.plexoCertificatePassword,
+        query.plexoCertificatePath,
+      )
+    }
+  
+    async PurchaseAsync(payment: PaymentRequest): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<PaymentRequest, ServerResponse<Transaction>>(
+        '/Operation/Purchase',
+        payment,
+        payment.plexoClientName,
+        payment.plexoCertificatePassword,
+        payment.plexoCertificatePath,
+      )
+    }
+  
+    async CreateBankInstrumentAsync(
+      request: CreateBankInstrumentRequest,
+    ): Promise<ServerResponse<PaymentInstrument>> {
+      return await requestToPlexo<CreateBankInstrumentRequest, ServerResponse<PaymentInstrument>>(
+        '/Instruments/Bank',
+        request,
+        request.plexoClientName,
+        request.plexoCertificatePassword,
+        request.plexoCertificatePath,
+      )
+    }
+  
+    async EndReserveAsync(reserve: Reserve): Promise<ServerResponse<Transaction>> {
+      return await requestToPlexo<Reserve, ServerResponse<Transaction>>(
+        '/Operation/EndReserve',
+        reserve,
+        reserve.plexoClientName,
+        reserve.plexoCertificatePassword,
+        reserve.plexoCertificatePath,
+      )
+    }*/
+    PaymentGatewayClient.prototype.UnwrapInstrumentCallbackAsync = function (serverSignedInstrumentCallback, plexoUrl) {
         return __awaiter(this, void 0, void 0, 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, plexoUrl)];
                     case 1:
                         verify = _a.sent();
                         return [2 /*return*/, verify];
@@ -334,14 +415,12 @@ var PaymentGatewayClient = /** @class */ (function () {
             });
         });
     };
-    PaymentGatewayClient.prototype.UnwrapTransactionCallbackAsync = function (serverSignedTransactionCallback) {
+    PaymentGatewayClient.prototype.UnwrapTransactionCallbackAsync = function (serverSignedTransactionCallback, plexoUrl) {
         return __awaiter(this, void 0, void 0, function () {
             var verify;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        logger_lib_1.default.info("SERVER SIGNED CALLBACK --> ".concat(JSON.stringify(serverSignedTransactionCallback)));
-                        return [4 /*yield*/, signatureHelper_1.SignatureHelper.getPlexoSignature(serverSignedTransactionCallback.object.fingerprint, serverSignedTransactionCallback)];
+                    case 0: return [4 /*yield*/, signatureHelper_1.SignatureHelper.unwrapCallback(serverSignedTransactionCallback.object.fingerprint, serverSignedTransactionCallback, plexoUrl)];
                     case 1:
                         verify = _a.sent();
                         return [2 /*return*/, verify];
@@ -349,12 +428,12 @@ var PaymentGatewayClient = /** @class */ (function () {
             });
         });
     };
-    PaymentGatewayClient.prototype.SignInstrumentCallback = function (serverResponse) {
+    PaymentGatewayClient.prototype.SignInstrumentCallback = function (serverResponse, plexoCertificatePath, plexoCertificatePassword) {
         return __awaiter(this, void 0, void 0, 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, plexoCertificatePath, plexoCertificatePassword)];
                     case 1:
                         response = _a.sent();
                         return [2 /*return*/, response];
@@ -362,12 +441,12 @@ var PaymentGatewayClient = /** @class */ (function () {
             });
         });
     };
-    PaymentGatewayClient.prototype.SignTransactionCallback = function (serverResponse) {
+    PaymentGatewayClient.prototype.SignTransactionCallback = function (serverResponse, plexoCertificatePath, plexoCertificatePassword) {
         return __awaiter(this, void 0, void 0, 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, plexoCertificatePath, plexoCertificatePassword)];
                     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>, plexoCertificatePassword: string, plexoCertificatePath: string) => Promise<GenericSignedObject<T>>;
+    unwrapCallback: <T_1 extends object>(fingerprint: string, response: GenericSignedObject<T_1>, plexoUrl: string) => Promise<ServerResponse<T_1>>;
+    signCallback: (response: ServerResponse<InstrumentCallback | TransactionCallback>, plexoCertificatePath: string, plexoCertificatePassword: string) => Promise<ClientSignedResponse>;
 };