@traxionpay/cbsmiddleware 0.0.1

package/src/banking/services/WelcomeBank.service.ts

@@ -0,0 +1,990 @@
+import { Inject, Injectable, HttpException, HttpStatus } from '@nestjs/common';
+import { BankService } from '../interfaces/bank-service.interface';
+import axios from 'axios';
+import { AxiosErrorHelper } from '../../helpers/axios-error.helper';
+import { BankingConfig } from '../interfaces/bank-config.interface';
+import { BANKING_CONFIG } from '../tokens/bank-service.tokens';
+import * as https from 'https';
+import * as speakeasy from 'speakeasy';
+import * as CryptoJS from 'crypto-js';
+import { Logger } from 'nestjs-pino';
+import { AccountDto, ValidateOtp } from '../dto/account.dto';
+import { TransactionHistoryDto } from '../dto/transaction-history.dto'
+import { AccountTransferDto } from '../dto/account-transfer.dto'
+import { FetchBankBalanceDto } from '../dto/fetch-bank-balance.dto';
+
+
+@Injectable()
+export class WelcomeBankService implements BankService {
+
+  private readonly secretKey = '5HZ3HAX4MVCGFH3EWYP3U62QRDR6R3TD';
+
+  constructor(
+    @Inject(BANKING_CONFIG)
+    private readonly config: BankingConfig,
+    private readonly logger: Logger
+  ) {
+  }
+
+  generateTOTP(serverTimestamp: string | number): string {
+    const timeInSeconds = typeof serverTimestamp === 'string'
+      ? Math.floor(Date.parse(serverTimestamp) / 1000)
+      : serverTimestamp;
+    return speakeasy.totp({
+      secret: this.secretKey,
+      encoding: 'base32',
+      step: 30,
+      algorithm: 'sha1',
+      digits: 6,
+      time: timeInSeconds,
+    });
+  }
+
+  encryptPayloadWithOTP(payload: any, otp: string): string {
+    const stringified = JSON.stringify(payload);
+    const encrypted = CryptoJS.AES.encrypt(stringified, otp).toString();
+    return encrypted;
+  }
+
+  private decryptPayloadWithOTP(encryptedPayload: string, otp: string): any {
+
+    const decrypted = CryptoJS.AES.decrypt(encryptedPayload, otp);
+    const plaintext = decrypted.toString(CryptoJS.enc.Utf8);
+
+    try {
+      return JSON.parse(plaintext);
+    } catch (err) {
+      this.logger.error("Failed to JSON.parse decrypted payload", err);
+
+      throw new Error("Decryption or JSON parsing failed");
+    }
+  }
+
+  async generateToken(): Promise<any> {
+
+    this.logger.log("Generating WelcomeBank Token");
+
+    try {
+      const headers = {
+        'Content-Type': 'application/json',
+        'X-API-KEY': `${this.config.WELCOMEBANK_API_KEY}`,
+        'X-API-VERSION': `${this.config.WELCOMEBANK_VERSION_KEY}`
+      };
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.get(
+        `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/token/generate`,
+        {
+          headers: headers,
+          httpsAgent,
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Token generated successfully');
+
+      return {
+        success: true,
+        ...response.data,
+      };
+
+    } catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async refreshToken(refreshToken: string): Promise<any> {
+
+    if (!refreshToken) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020206,
+        message: 'Bank token should not be empty.',
+        data: { refreshToken }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+
+    this.logger.log("Welcome Bank refresh token");
+
+    try {
+      const headers = {
+        'Content-Type': 'application/json',
+      };
+
+      const payload = {
+        "refreshToken": refreshToken
+      }
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/token/refresh`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent,
+        }
+      );
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Refresh Token Successful');
+
+      return {
+        success: true,
+        ...response.data,
+      };
+
+    } catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async linkAccount(accountDto: AccountDto) {
+
+    const { token, account, branch, accountType, mobile } = accountDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 401020302,
+        message: 'Bank token should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020304,
+        message: 'Bank account number should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!accountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4400020306,
+        message: 'Bank account type should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!mobile) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 4000203009,
+        message: 'Mobile Number should not be empty.',
+        data: { accountDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank Link Account");
+
+    const isoTimestamp = new Date().toISOString();
+    const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+    const totp = this.generateTOTP(timeInSeconds);
+    const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+
+    this.logger.log(`TOTP GENERATED FOR WELCOMEBANK LINK ACCOUNT: ${totp}, For Time stamp: ${isoTimestamp}`);
+    this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-SERVER-TIMESTAMP': `${isoTimestamp}`
+      };
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      let response;
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+        let payload;
+        payload = {
+          "acc": account,
+          "br": branch,
+          "accType": accountType,
+          "mobile": mobile
+        }
+        payload = this.encryptPayloadWithOTP(payload, totp);
+        const encodedPayload = encodeURIComponent(payload);
+
+        response = await axios.get(
+          `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/linkaccount?data=${encodedPayload}`,
+          {
+            headers: headers,
+            httpsAgent
+          }
+        );
+      }
+
+      else {
+        response = await axios.get(
+          `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/linkaccount?acc=${account}&br=${branch}&accType=${accountType}&mobile=${mobile}`,
+          {
+            headers: headers,
+            httpsAgent
+          }
+        );
+      }
+      let responseData = response.data;
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Link Account Successful');
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+
+        const encryptedResponsePayload = responseData.data;
+
+        if (!encryptedResponsePayload) {
+          throw new Error("Encrypted response expected but not found");
+        }
+
+        let decryptedResponse;
+        try {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+        } catch (error) {
+          this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+        }
+
+        if (!decryptedResponse) {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+        }
+
+        return {
+          success: true,
+          data: decryptedResponse,
+        };
+
+      } else {
+
+        return {
+          success: true,
+          ...responseData,
+        };
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+
+  async validateOtp(validateOtp: ValidateOtp): Promise<any> {
+
+    const { token, account, branch, accountType, otp } = validateOtp;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 401020402,
+        message: 'Bank token should not be empty.',
+        data: { validateOtp }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020404,
+        message: 'Bank account number should not be empty.',
+        data: { validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!accountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020406,
+        message: 'Bank account type should not be empty.',
+        data: { validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!otp) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020408,
+        message: 'Mobile Number should not be empty.',
+        data: { validateOtp }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank Validate OTP");
+
+    const isoTimestamp = new Date().toISOString();
+    const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+    const totp = this.generateTOTP(timeInSeconds);
+    const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+
+    this.logger.log(`TOTP GENERATED FOR WELCOME BANK VALIDATE OTP: ${totp}, For Time stamp: ${isoTimestamp}`);
+    this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-SERVER-TIMESTAMP': `${isoTimestamp}`
+      };
+
+      let payload;
+
+      payload = {
+        "acc": account,
+        "br": branch,
+        "accType": accountType,
+        "otp": otp
+      }
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/validateotp`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      let responseData = response.data;
+      this.logger.log({ responseData: response }, 'Welcome Bank Validate OTP Successful');
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+
+        const encryptedResponsePayload = responseData.data;
+
+        if (!encryptedResponsePayload) {
+          throw new Error("Encrypted response expected but not found");
+        }
+
+        let decryptedResponse;
+        try {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+        } catch (error) {
+          this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+        }
+
+        if (!decryptedResponse) {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+        }
+
+        return {
+          success: true,
+          data: decryptedResponse,
+        };
+
+      } else {
+
+        return {
+          success: true,
+          ...responseData,
+        };
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async processBalanceTransaction(fetchBalanceDto: FetchBankBalanceDto): Promise<any> {
+
+    const { token, permissionKey, account, branch, accountType } = fetchBalanceDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 401020502,
+        message: 'Bank token should not be empty.',
+        data: { fetchBalanceDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!permissionKey) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 403020504,
+        message: 'Bank permission key should not be empty.',
+        data: { fetchBalanceDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020506,
+        message: 'Bank account number should not be empty.',
+        data: { fetchBalanceDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!accountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020508,
+        message: 'Bank account type should not be empty.',
+        data: { fetchBalanceDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank Balance Inquiry");
+
+    const isoTimestamp = new Date().toISOString();
+    const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+    const totp = this.generateTOTP(timeInSeconds);
+    const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+    this.logger.log(`TOTP GENERATED FOR WELCOME BANK BALANCE INQUIRY: ${totp}, For Time stamp: ${isoTimestamp}`);
+    this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+      };
+
+      let payload;
+
+      payload = {
+        "acc": account,
+        "br": branch,
+        "accType": accountType,
+        "permissionKey": permissionKey,
+      }
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/balanceinquiry`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      let responseData = response.data;
+
+      this.logger.log({ responseData: response }, 'Welcome Bank Balance Inquiry Successful');
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+
+        const encryptedResponsePayload = responseData.data;
+
+        if (!encryptedResponsePayload) {
+          throw new Error("Encrypted response expected but not found");
+        }
+
+        let decryptedResponse;
+        try {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+        } catch (error) {
+          this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+        }
+
+        if (!decryptedResponse) {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+        }
+        return {
+          success: true,
+          data: decryptedResponse,
+        };
+
+      } else {
+
+        return {
+          success: true,
+          ...responseData,
+        };
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async accountCashIn(accountTransferDto: AccountTransferDto): Promise<any> {
+
+    const { token, permissionKey, sourceAccount, sourceBranch, sourceAccountType, destinationAccount, destinationBranch, destinationAccountType, amount } = accountTransferDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 401020602,
+        message: 'Bank token should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!permissionKey) {
+      throw new HttpException({
+        statusCode: HttpStatus.FORBIDDEN,
+        code: 403020604,
+        message: 'Bank permission key should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.FORBIDDEN);
+    }
+
+    if (!sourceAccount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020606,
+        message: 'Bank source account number should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!sourceAccountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020608,
+        message: 'Bank source account type should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!destinationAccount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020610,
+        message: 'Bank destination account number should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!destinationAccountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020612,
+        message: 'Bank destination account type should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!amount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020613,
+        message: 'Amount should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank cash in");
+
+    const isoTimestamp = new Date().toISOString();
+    const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+    const totp = this.generateTOTP(timeInSeconds);
+    const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+
+    this.logger.log(`TOTP GENERATED FOR WELCOME BANK CASH IN: ${totp}, For Time stamp: ${isoTimestamp}`);
+    this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+      };
+
+      let payload;
+
+      payload = {
+        "permissionKey": permissionKey,
+        "sourceAcc": sourceAccount,
+        "sourceBr": sourceBranch,
+        "sourceAccType": sourceAccountType,
+        "destAcc": destinationAccount,
+        "destBr": destinationBranch,
+        "destAccType": destinationAccountType,
+        "trnAmt": amount
+      }
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/cashin`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      let responseData = response.data;
+      this.logger.log({ responseData: response }, 'Welcome Bank Cash In Successful');
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+
+        const encryptedResponsePayload = responseData.data;
+
+        if (!encryptedResponsePayload) {
+          throw new Error("Encrypted response expected but not found");
+        }
+
+        let decryptedResponse;
+        try {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+        } catch (error) {
+          this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+        }
+
+        if (!decryptedResponse) {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+        }
+
+        return {
+          success: true,
+          data: decryptedResponse,
+        };
+
+      } else {
+
+        return {
+          success: true,
+          ...responseData,
+        };
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async accountDeposit(accountTransferDto: AccountTransferDto): Promise<any> {
+
+    const { token, permissionKey, sourceAccount, sourceBranch, sourceAccountType, destinationAccount, destinationBranch, destinationAccountType, amount } = accountTransferDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 401020702,
+        message: 'Bank token should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!permissionKey) {
+      throw new HttpException({
+        statusCode: HttpStatus.FORBIDDEN,
+        code: 403020704,
+        message: 'Bank permission key should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.FORBIDDEN);
+    }
+
+    if (!sourceAccount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020706,
+        message: 'Bank source account number should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!sourceAccountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020708,
+        message: 'Bank source account type should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!destinationAccount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020710,
+        message: 'Bank destination account number should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!destinationAccountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020712,
+        message: 'Bank destination account type should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!amount) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020713,
+        message: 'Amount should not be empty.',
+        data: { accountTransferDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank deposit");
+
+    const isoTimestamp = new Date().toISOString();
+    const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+    const totp = this.generateTOTP(timeInSeconds);
+    const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+
+    this.logger.log(`TOTP GENERATED FOR WELCOME BANK DEPOSIT: ${totp}, For Time stamp: ${isoTimestamp}`);
+    this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+      };
+
+
+      let payload;
+      payload = {
+        "permissionKey": permissionKey,
+        "sourceAcc": sourceAccount,
+        "sourceBr": sourceBranch,
+        "sourceAccType": sourceAccountType,
+        "destAcc": destinationAccount,
+        "destBr": destinationBranch,
+        "destAccType": destinationAccountType,
+        "trnAmt": amount
+      }
+
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/customerdeposit`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+
+      let responseData = response.data;
+      this.logger.log({ responseData: response.data }, 'Welcom Bank Deposit Successful');
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+
+        const encryptedResponsePayload = responseData.data;
+
+        if (!encryptedResponsePayload) {
+          throw new Error("Encrypted response expected but not found");
+        }
+
+        let decryptedResponse;
+        try {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+        } catch (error) {
+          this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+        }
+
+        if (!decryptedResponse) {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+        }
+
+        return {
+          success: true,
+          data: decryptedResponse,
+        };
+
+      } else {
+
+        return {
+          success: true,
+          ...responseData,
+        };
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async getTransactionHistory(transactionHistoryDto: TransactionHistoryDto) {
+
+    const { token, permissionKey, account, branch, accountType, dateFrom, dateTo, page } = transactionHistoryDto;
+
+    if (!token) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNAUTHORIZED,
+        code: 401020802,
+        message: 'Bank token should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.UNAUTHORIZED);
+    }
+
+    if (!permissionKey) {
+      throw new HttpException({
+        statusCode: HttpStatus.FORBIDDEN,
+        code: 403020804,
+        message: 'Bank permission key should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.FORBIDDEN);
+    }
+
+    if (!account) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020806,
+        message: 'Bank account number should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!accountType) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020808,
+        message: 'Bank account type should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!dateFrom) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020810,
+        message: 'Date From should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    if (!dateTo) {
+      throw new HttpException({
+        statusCode: HttpStatus.BAD_REQUEST,
+        code: 400020812,
+        message: 'Date From should not be empty.',
+        data: { transactionHistoryDto }
+      }, HttpStatus.BAD_REQUEST);
+    }
+
+    this.logger.log("Welcome Bank transaction history");
+
+    const isoTimestamp = new Date().toISOString();
+    const timeInSeconds = Math.floor(Date.parse(isoTimestamp) / 1000);
+    const totp = this.generateTOTP(timeInSeconds);
+    const totpPrevious = this.generateTOTP(timeInSeconds - 30);
+
+    this.logger.log(`TOTP GENERATED FOR WELCOME BANK VALIDATE OTP: ${totp}, For Time stamp: ${isoTimestamp}`);
+    this.logger.log(`TOTP GENERATED FOR PREVIOUS TIME: ${totpPrevious}`);
+
+    try {
+      const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'X-SERVER-TIMESTAMP': `${new Date().toISOString()}`
+      };
+
+      let payload;
+      payload = {
+        "acc": account,
+        "br": branch,
+        "accType": accountType,
+        "permissionKey": permissionKey,
+        "dateFrom": dateFrom,
+        "dateTo": dateTo,
+        "pageNo": page
+      }
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+        payload = {data: this.encryptPayloadWithOTP(payload, totp)};
+      }
+
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.post(
+        `${this.config.WELCOMEBANK_URL}:${this.config.WELCOMEBANK_PORT}/api/transhistory`,
+        payload,
+        {
+          headers: headers,
+          httpsAgent
+        }
+      );
+      let responseData = response.data;
+      this.logger.log({ responseData: response.data }, 'Welcome Bank Transaction History Successful');
+
+      if (String(this.config.WELCOMBANK_ENABLEENCRYPTION).toLowerCase() === 'true') {
+
+        const encryptedResponsePayload = responseData.data;
+
+        if (!encryptedResponsePayload) {
+          throw new Error("Encrypted response expected but not found");
+        }
+
+        let decryptedResponse;
+        try {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totp);
+        } catch (error) {
+          this.logger.warn("Decryption with current OTP failed, trying with previous OTP");
+        }
+
+        if (!decryptedResponse) {
+          decryptedResponse = this.decryptPayloadWithOTP(encryptedResponsePayload, totpPrevious);
+        }
+
+        return {
+          success: true,
+          data: decryptedResponse,
+        };
+
+      } else {
+
+        return {
+          success: true,
+          ...responseData,
+        };
+      }
+    }
+    catch (error) {
+      AxiosErrorHelper.handleAxiosError(error);
+    }
+  }
+
+  async findAccountDetailsRaw(token: string, userid: number) {
+    return "Sorry Service Currently Unavaible";
+  }
+
+  async accountTransfer(token: string, useridFrom: string, useridTo: string, amount: number) {
+    return "Sorry Service Currently Unavaible";
+  }
+
+  generateOtp(mobile: string, acc: string, bankid: string): string {
+    return "Sorry Service Currently Unavaible";
+  }
+
+  generateRandomOtp(length: number): string {
+    return "Sorry Service Currently Unavaible";
+  }
+}