@houlak/plexo-sdk 0.1.11 → 0.1.12-fx

package/lib/sdk/PaymentGatewayClient.d.ts

@@ -1,32 +1,33 @@
 import { Authorization, AuthorizationInfo, CancelRequest, ClientSignedResponse, CodeRequest, Commerce, CommerceIdRequest, CommerceIssuerIdRequest, CommerceModifyRequest, CommerceRequest, CreateBankInstrumentRequest, DeleteInstrumentRequest, ExpressCheckoutRequest, InstrumentCallback, IssuerData, IssuerInfo, PaymentRequest, PaymentInstrument, Reference, Reserve, ReserveRequest, BaseServerResponse, ServerResponse, ServerSignedCallback, Session, Transaction, TransactionCallback, TransactionCursor, TransactionQuery } from './models/IndexSDK';
 import { IssuerProcessor } from './index';
 import { IPaymentGatewayClient } from './IPaymentGatewayClient';
+import { FixedCustomData } from './models/FixedCustomData';
 export declare class PaymentGatewayClient implements IPaymentGatewayClient {
-    AddCommerceAsync(commerce: CommerceRequest): Promise<ServerResponse<Commerce>>;
-    AddIssuerCommerceAsync(issuerData: IssuerData): Promise<ServerResponse<IssuerData>>;
-    DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<ServerResponse<BaseServerResponse>>;
-    DeleteInstrumentAsync(info: DeleteInstrumentRequest): Promise<ServerResponse<BaseServerResponse>>;
-    DeleteIssuerCommerceAsync(commerceIssuerIdRequest: CommerceIssuerIdRequest): Promise<ServerResponse<BaseServerResponse>>;
-    GetCommerceIssuersAsync(commerceIdRequest: CommerceIdRequest): Promise<ServerResponse<IssuerData[]>>;
-    GetCommercesAsync(): Promise<ServerResponse<Commerce[]>>;
-    GetSupportedIssuersAsync(): Promise<ServerResponse<IssuerInfo[]>>;
-    GetSupportedPaymentProcessorsAsync(): Promise<ServerResponse<IssuerProcessor[]>>;
-    ModifyCommerceAsync(commerceModifyRequest: CommerceModifyRequest): Promise<ServerResponse<Commerce>>;
-    GetInstrumentsAsync(authorizationInfo: AuthorizationInfo): Promise<ServerResponse<PaymentInstrument[]>>;
-    SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse>;
-    AuthorizeAsync(authorization: Authorization): Promise<ServerResponse<Session>>;
-    CancelAsync(cancel: CancelRequest): Promise<ServerResponse<Transaction>>;
-    CodeActionAsync(request: CodeRequest): Promise<ServerResponse<Transaction>>;
-    StartReserveAsync(payment: ReserveRequest): Promise<ServerResponse<Transaction>>;
-    StatusAsync(payment: Reference): Promise<ServerResponse<Transaction>>;
-    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest): Promise<ServerResponse<Session>>;
-    ObtainCsvTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<string>>;
-    ObtainTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<TransactionCursor>>;
-    PurchaseAsync(payment: PaymentRequest): Promise<ServerResponse<Transaction>>;
-    CreateBankInstrumentAsync(request: CreateBankInstrumentRequest): Promise<ServerResponse<PaymentInstrument>>;
-    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>>;
+    AddCommerceAsync(commerce: CommerceRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce>>;
+    AddIssuerCommerceAsync(issuerData: IssuerData, fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerData>>;
+    DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<BaseServerResponse>>;
+    DeleteInstrumentAsync(info: DeleteInstrumentRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<BaseServerResponse>>;
+    DeleteIssuerCommerceAsync(commerceIssuerIdRequest: CommerceIssuerIdRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<BaseServerResponse>>;
+    GetCommerceIssuersAsync(commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerData[]>>;
+    GetCommercesAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce[]>>;
+    GetSupportedIssuersAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerInfo[]>>;
+    GetSupportedPaymentProcessorsAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerProcessor[]>>;
+    ModifyCommerceAsync(commerceModifyRequest: CommerceModifyRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce>>;
+    GetInstrumentsAsync(authorizationInfo: AuthorizationInfo, fixedCustomData: FixedCustomData): Promise<ServerResponse<PaymentInstrument[]>>;
+    SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData): Promise<BaseServerResponse>;
+    AuthorizeAsync(authorization: Authorization, fixedCustomData: FixedCustomData): Promise<ServerResponse<Session>>;
+    CancelAsync(cancel: CancelRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    CodeActionAsync(request: CodeRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    StartReserveAsync(payment: ReserveRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    StatusAsync(payment: Reference, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Session>>;
+    ObtainCsvTransactionsAsync(query: TransactionQuery, fixedCustomData: FixedCustomData): Promise<ServerResponse<string>>;
+    ObtainTransactionsAsync(query: TransactionQuery, fixedCustomData: FixedCustomData): Promise<ServerResponse<TransactionCursor>>;
+    PurchaseAsync(payment: PaymentRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    CreateBankInstrumentAsync(request: CreateBankInstrumentRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<PaymentInstrument>>;
+    EndReserveAsync(reserve: Reserve, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    UnwrapInstrumentCallbackAsync(serverSignedInstrumentCallback: ServerSignedCallback<InstrumentCallback>, plexoUrl: string): Promise<ServerResponse<InstrumentCallback>>;
+    UnwrapTransactionCallbackAsync(serverSignedTransactionCallback: ServerSignedCallback<TransactionCallback>, plexoUrl: string): Promise<ServerResponse<TransactionCallback>>;
+    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>, plexoCertificatePath: string, plexoCertificatePassword: string): Promise<ClientSignedResponse>;
+    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>, plexoCertificatePath: string, plexoCertificatePassword: string): Promise<ClientSignedResponse>;
 }

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 client = axios_1.default.create({
-    baseURL: config_1.config.plexoUrl,
-});
-var requestToPlexo = function (endpoint, request) { return __awaiter(void 0, void 0, void 0, function () {
-    var object, stateObject, signedClientRequest, data, err_1;
+var utils_1 = require("../utils");
+var requestToPlexo = function (endpoint, request, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var object, stateObject, signedClientRequest, client, 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: '',
+                    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)));
+                client = axios_1.default.create({
+                    baseURL: fixedCustomData.plexoUrl,
+                });
+                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,242 @@ var requestToPlexo = function (endpoint, request) { return __awaiter(void 0, voi
 var PaymentGatewayClient = /** @class */ (function () {
     function PaymentGatewayClient() {
     }
-    PaymentGatewayClient.prototype.AddCommerceAsync = function (commerce) {
+    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('/Commerce/Add', commerce)];
+                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce/Add', commerce, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.AddIssuerCommerceAsync = function (issuerData) {
+    PaymentGatewayClient.prototype.AddIssuerCommerceAsync = function (issuerData, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer/Add', issuerData, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.DeleteCommerceAsync = function (commerceIdRequest) {
+    PaymentGatewayClient.prototype.DeleteCommerceAsync = function (commerceIdRequest, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Commerce/Delete', commerceIdRequest, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.DeleteInstrumentAsync = function (info) {
+    PaymentGatewayClient.prototype.DeleteInstrumentAsync = function (info, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Instruments/Delete', info, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.DeleteIssuerCommerceAsync = function (commerceIssuerIdRequest) {
+    PaymentGatewayClient.prototype.DeleteIssuerCommerceAsync = function (commerceIssuerIdRequest, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer/Delete', commerceIssuerIdRequest, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.GetCommerceIssuersAsync = function (commerceIdRequest) {
+    PaymentGatewayClient.prototype.GetCommerceIssuersAsync = function (commerceIdRequest, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Commerce/Issuer', commerceIdRequest, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.GetCommercesAsync = function () {
+    PaymentGatewayClient.prototype.GetCommercesAsync = function (fixedCustomData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce', '')];
+                    case 0: return [4 /*yield*/, requestToPlexo('/Commerce', '', fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.GetSupportedIssuersAsync = function () {
+    PaymentGatewayClient.prototype.GetSupportedIssuersAsync = function (fixedCustomData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/Issuer', '')];
+                    case 0: return [4 /*yield*/, requestToPlexo('/Issuer', '', fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.GetSupportedPaymentProcessorsAsync = function () {
+    PaymentGatewayClient.prototype.GetSupportedPaymentProcessorsAsync = function (fixedCustomData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, requestToPlexo('/PaymentProcessors', '')];
+                    case 0: return [4 /*yield*/, requestToPlexo('/PaymentProcessors', '', fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.ModifyCommerceAsync = function (commerceModifyRequest) {
+    PaymentGatewayClient.prototype.ModifyCommerceAsync = function (commerceModifyRequest, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Commerce/Modify', commerceModifyRequest, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.GetInstrumentsAsync = function (authorizationInfo) {
+    PaymentGatewayClient.prototype.GetInstrumentsAsync = function (authorizationInfo, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Instruments', authorizationInfo, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.SetDefaultCommerceAsync = function (commerceIdRequest) {
+    PaymentGatewayClient.prototype.SetDefaultCommerceAsync = function (commerceIdRequest, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Commerce/SetDefault', commerceIdRequest, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.AuthorizeAsync = function (authorization) {
+    PaymentGatewayClient.prototype.AuthorizeAsync = function (authorization, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Auth', authorization, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.CancelAsync = function (cancel) {
+    PaymentGatewayClient.prototype.CancelAsync = function (cancel, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Operation/Cancel', cancel, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.CodeActionAsync = function (request) {
+    PaymentGatewayClient.prototype.CodeActionAsync = function (request, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Code', request, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.StartReserveAsync = function (payment) {
+    PaymentGatewayClient.prototype.StartReserveAsync = function (payment, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Operation/StartReserve', payment, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.StatusAsync = function (payment) {
+    PaymentGatewayClient.prototype.StatusAsync = function (payment, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Operation/Status', payment, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.ExpressCheckoutAsync = function (expressCheckout) {
+    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('/ExpressCheckout', expressCheckout)];
+                    case 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', expressCheckout, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.ObtainCsvTransactionsAsync = function (query) {
+    PaymentGatewayClient.prototype.ObtainCsvTransactionsAsync = function (query, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/ExpressCheckout', query, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.ObtainTransactionsAsync = function (query) {
+    PaymentGatewayClient.prototype.ObtainTransactionsAsync = function (query, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Transactions', query, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.PurchaseAsync = function (payment) {
+    PaymentGatewayClient.prototype.PurchaseAsync = function (payment, fixedCustomData) {
         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 0: return [4 /*yield*/, requestToPlexo('/Operation/Purchase', payment, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.CreateBankInstrumentAsync = function (request) {
+    PaymentGatewayClient.prototype.CreateBankInstrumentAsync = function (request, 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('/Instruments/Bank', request, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.EndReserveAsync = function (reserve) {
+    PaymentGatewayClient.prototype.EndReserveAsync = function (reserve, 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('/Operation/EndReserve', reserve, fixedCustomData)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
-    PaymentGatewayClient.prototype.UnwrapInstrumentCallbackAsync = function (serverSignedInstrumentCallback) {
+    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 +334,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.debug("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 +347,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 +360,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

@@ -276,7 +276,7 @@ var PaymentGatewayMock = /** @class */ (function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, {
                         resultCode: IndexSDK_1.ResultCodes.Ok,
-                        response: __assign(__assign({}, mocks_1.mocks.paymentInstrumentMock), { Issuer: __assign(__assign({}, mocks_1.mocks.paymentInstrumentMock.Issuer), { issuerId: request.issuerId }) }),
+                        response: __assign(__assign({}, mocks_1.mocks.paymentInstrumentMock), { issuer: __assign(__assign({}, mocks_1.mocks.paymentInstrumentMock.issuer), { issuerId: request.issuerId }) }),
                     }];
             });
         });
@@ -296,7 +296,7 @@ var PaymentGatewayMock = /** @class */ (function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, {
                         resultCode: IndexSDK_1.ResultCodes.Ok,
-                        response: __assign(__assign({}, mocks_1.mocks.instrumentCallbackMock), serverSignedInstrumentCallback.Object),
+                        response: __assign(__assign({}, mocks_1.mocks.instrumentCallbackMock), serverSignedInstrumentCallback.object),
                     }];
             });
         });
@@ -306,7 +306,7 @@ var PaymentGatewayMock = /** @class */ (function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, {
                         resultCode: IndexSDK_1.ResultCodes.Ok,
-                        response: __assign(__assign({}, mocks_1.mocks.transactionCallbackMock), serverSignedTransactionCallback.Object),
+                        response: __assign(__assign({}, mocks_1.mocks.transactionCallbackMock), serverSignedTransactionCallback.object),
                     }];
             });
         });
@@ -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>;
 };