@houlak/plexo-sdk 0.1.8 → 0.1.9-fx

package/lib/sdk/PaymentGatewayClient.js

@@ -50,36 +50,36 @@ 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 = {
-                    Fingerprint: '',
-                    UtcUnixTimeExpiration: Date.parse(new Date().toString()),
-                    Object: object,
+                    fingerprint: '',
+                    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,12 +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: 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];
@@ -347,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];
@@ -360,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>;
 }