@develit-services/bank 0.7.0 → 0.7.1

package/dist/shared/{bank.DEvSNsEs.cjs → bank.CTqIXnHg.cjs}

@@ -2,11 +2,11 @@
 
 const backendSdk = require('@develit-io/backend-sdk');
 const drizzleOrm = require('drizzle-orm');
-const database_schema = require('./bank.c38V_FCq.cjs');
+const database_schema = require('./bank.DlW1XNug.cjs');
 require('date-fns');
 require('@develit-io/general-codes');
 require('jose');
-require('./bank.BeIpkWR-.cjs');
+require('./bank.D7kwLMqF.cjs');
 const node_crypto = require('node:crypto');
 
 const createPaymentCommand = (db, { payment }) => {

package/dist/shared/{bank.DFIwAQqg.mjs → bank.CTtFAN03.mjs}

@@ -1,4 +1,4 @@
-import { n as account, p as accountCredentials, q as batch, r as ott, s as payment, t as paymentRelations } from './bank.DLWegh_f.mjs';
+import { n as account, p as accountCredentials, q as batch, r as ott, s as payment, t as paymentRelations } from './bank.BnIYdBEF.mjs';
 
 const schema = {
 	__proto__: null,

package/dist/shared/{bank.Dq27-5wD.mjs → bank.CkUMU1sJ.mjs}

@@ -1,12 +1,97 @@
 import { uuidv4, useResult, createInternalError } from '@develit-io/backend-sdk';
 import { format, parseISO } from 'date-fns';
 import { CURRENCY_CODES } from '@develit-io/general-codes';
-import './bank.DLWegh_f.mjs';
+import './bank.BnIYdBEF.mjs';
 import 'drizzle-orm';
 import { importPKCS8, SignJWT } from 'jose';
 import 'node:crypto';
 
 class IBankConnector {
+  // ── Deprecated methods (backward compatibility) ────────────────────
+  /**
+   * @deprecated Use initiateDomesticBatch, initiateSEPABatch, or initiateForeignBatch instead.
+   * Delegates to initiateDomesticBatch for backward compatibility.
+   */
+  initiateBatch(args) {
+    return this.initiateDomesticBatch(args);
+  }
+  /**
+   * @deprecated Use initiateDomesticPayment instead.
+   * Delegates to initiateDomesticPayment for backward compatibility.
+   */
+  initiateSinglePayment(payment) {
+    return this.initiateDomesticPayment(payment);
+  }
+  // ── Batch methods ─────────────────────────────────────────────────
+  /**
+   * Initiates a batch of domestic payments with the bank.
+   * Falls back to single payments if batch not supported.
+   * @param batchId - Unique identifier for the batch
+   * @param payments - Array of domestic payments to include in the batch
+   * @returns Batch initiation result with authorization URLs and prepared payments
+   */
+  async initiateDomesticBatch({
+    batchId,
+    payments
+  }) {
+    if (!this.supportsBatch("DOMESTIC")) {
+      const authorizationUrls = [];
+      const preparedPayments = [];
+      for (const payment of payments) {
+        const initiated = await this.initiateDomesticPayment(payment);
+        authorizationUrls.push(initiated.authorizationUrl);
+        preparedPayments.push(initiated.payment);
+      }
+      return { id: batchId, authorizationUrls, payments: preparedPayments };
+    }
+    return this.initiateDomesticBatchImpl({ batchId, payments });
+  }
+  /**
+   * Initiates a batch of SEPA payments with the bank.
+   * Falls back to single payments if batch not supported.
+   * @param batchId - Unique identifier for the batch
+   * @param payments - Array of SEPA payments to include in the batch
+   * @returns Batch initiation result with authorization URLs and prepared payments
+   */
+  async initiateSEPABatch({
+    batchId,
+    payments
+  }) {
+    if (!this.supportsBatch("SEPA")) {
+      const authorizationUrls = [];
+      const preparedPayments = [];
+      for (const payment of payments) {
+        const initiated = await this.initiateSEPAPayment(payment);
+        authorizationUrls.push(initiated.authorizationUrl);
+        preparedPayments.push(initiated.payment);
+      }
+      return { id: batchId, authorizationUrls, payments: preparedPayments };
+    }
+    return this.initiateSEPABatchImpl({ batchId, payments });
+  }
+  /**
+   * Initiates a batch of foreign (SWIFT) payments with the bank.
+   * Falls back to single payments if batch not supported.
+   * @param batchId - Unique identifier for the batch
+   * @param payments - Array of foreign payments to include in the batch
+   * @returns Batch initiation result with authorization URLs and prepared payments
+   */
+  async initiateForeignBatch({
+    batchId,
+    payments
+  }) {
+    if (!this.supportsBatch("SWIFT")) {
+      const authorizationUrls = [];
+      const preparedPayments = [];
+      for (const payment of payments) {
+        const initiated = await this.initiateForeignPayment(payment);
+        authorizationUrls.push(initiated.authorizationUrl);
+        preparedPayments.push(initiated.payment);
+      }
+      return { id: batchId, authorizationUrls, payments: preparedPayments };
+    }
+    return this.initiateForeignBatchImpl({ batchId, payments });
+  }
 }
 
 function toIncomingPayment(input) {
@@ -32,7 +117,9 @@ function toIncomingPayment(input) {
     creditorIban: input.creditor.iban || null,
     debtor: input.debtor,
     debtorIban: input.debtor.iban || null,
-    sendAsSinglePayment: input.sendAsSinglePayment
+    sendAsSinglePayment: input.sendAsSinglePayment,
+    chargeBearer: input.chargeBearer,
+    instructionPriority: input.instructionPriority
   };
 }
 function assignAccount(payment, account) {
@@ -270,21 +357,21 @@ const mapFinbricksTransactionToPayment = (tx, account) => {
     ),
     creditor: {
       holderName: related?.creditorAccount?.name || related?.creditor?.name || "Unknown",
-      iban: isIncoming ? account.iban || void 0 : related.creditorAccount?.identification?.iban || account.iban || void 0,
-      number: isIncoming ? account.number || void 0 : related.creditorAccount?.identification?.other?.identification ? related.creditorAccount.identification.other.identification.split(
+      iban: isIncoming ? account.iban || void 0 : related?.creditorAccount?.identification?.iban || account.iban || void 0,
+      number: isIncoming ? account.number || void 0 : related?.creditorAccount?.identification?.other?.identification ? related.creditorAccount.identification.other.identification.split(
         "/"
       )[0] : account.number || void 0,
-      bankCode: isIncoming ? account.bankCode || void 0 : related.creditorAccount?.identification?.other?.identification ? related.creditorAccount.identification.other.identification.split(
+      bankCode: isIncoming ? account.bankCode || void 0 : related?.creditorAccount?.identification?.other?.identification ? related.creditorAccount.identification.other.identification.split(
         "/"
       )[1] : account.bankCode || void 0
     },
     debtor: {
       holderName: related?.debtorAccount?.name || related?.debtor?.name || "Unknown",
-      iban: isIncoming ? related.debtorAccount?.identification?.iban || account.iban || void 0 : account.iban ?? void 0,
-      number: isIncoming ? related.debtorAccount?.identification?.other?.identification ? related.debtorAccount.identification.other.identification.split(
+      iban: isIncoming ? related?.debtorAccount?.identification?.iban || account.iban || void 0 : account.iban ?? void 0,
+      number: isIncoming ? related?.debtorAccount?.identification?.other?.identification ? related.debtorAccount.identification.other.identification.split(
         "/"
       )[0] : account.number || void 0 : account.number || void 0,
-      bankCode: isIncoming ? related.debtorAccount?.identification?.other?.identification ? related.debtorAccount.identification.other.identification.split(
+      bankCode: isIncoming ? related?.debtorAccount?.identification?.other?.identification ? related.debtorAccount.identification.other.identification.split(
         "/"
       )[1] : account.bankCode || void 0 : account.bankCode || void 0
     },
@@ -452,7 +539,11 @@ class FinbricksConnector extends IBankConnector {
     }
     return response.accounts;
   }
-  async initiateBatch({
+  /**
+   * Native domestic batch implementation using Finbricks API.
+   * Called by base class when supportsBatch('DOMESTIC') returns true.
+   */
+  async initiateDomesticBatchImpl({
     batchId,
     payments
   }) {
@@ -501,6 +592,12 @@ class FinbricksConnector extends IBankConnector {
       )
     };
   }
+  initiateSEPABatchImpl(_args) {
+    throw new Error("Finbricks: SEPA batch not implemented");
+  }
+  initiateForeignBatchImpl(_args) {
+    throw new Error("Finbricks: Foreign batch not implemented");
+  }
   async initiateForeignPayment(payment) {
     const bankRefId = uuidv4();
     const [response, error] = await useResult(
@@ -521,8 +618,7 @@ class FinbricksConnector extends IBankConnector {
             value: payment.amount,
             currency: payment.currency
           },
-          //TODO(danielklein-arch): add bearer to payment from payouts and replace static value here
-          chargeBearer: "SHA",
+          chargeBearer: payment.chargeBearer || "SHA",
           debtor: {
             accountIdentification: {
               type: "IBAN",
@@ -614,7 +710,7 @@ class FinbricksConnector extends IBankConnector {
       }
     };
   }
-  async initiateSinglePayment(payment) {
+  async initiateDomesticPayment(payment) {
     const [response, error] = await useResult(
       this.finbricks.request({
         endpoint: FINBRICKS_ENDPOINTS.TRANSACTION_INIT,
@@ -752,30 +848,56 @@ class AirBankConnector extends FinbricksConnector {
   constructor(config) {
     super("AIRBANK", config);
   }
+  supportsBatch(paymentType) {
+    return paymentType === "DOMESTIC";
+  }
 }
 
 class CreditasConnector extends FinbricksConnector {
   constructor(config) {
     super("CREDITAS", config);
   }
+  /**
+   * Creditas bank doesn't support batch payments at all.
+   */
+  supportsBatch() {
+    return false;
+  }
 }
 
 class CSASConnector extends FinbricksConnector {
   constructor(config) {
     super("CSAS", config);
   }
+  supportsBatch(paymentType) {
+    return paymentType === "DOMESTIC";
+  }
 }
 
 class FioConnector extends FinbricksConnector {
   constructor(config) {
     super("FIO", config);
   }
+  /**
+   * FIO supports batch only for DOMESTIC (CZK) payments.
+   * SEPA and SWIFT batch support is planned by Finbricks.
+   */
+  supportsBatch(paymentType) {
+    return paymentType === "DOMESTIC";
+  }
 }
 
 class MonetaConnector extends FinbricksConnector {
   constructor(config) {
     super("MONETA", config);
   }
+  /**
+   * MONETA supports batch only for DOMESTIC (CZK) payments.
+   * SEPA and SWIFT batch support is planned by Finbricks.
+   */
+  supportsBatch(paymentType) {
+    return paymentType === "DOMESTIC";
+  }
 }
 
 const isDeposit = (payment, creditorIban) => {
@@ -873,7 +995,11 @@ const initiateConnector = async ({
       return new DbuConnector({
         BASE_URL: env.DBUCS_BASE_URI,
         USERNAME: env.DBUCS_USERNAME,
-        KV: env.BANK_KV
+        KV: env.BANK_KV,
+        API: env.DBU_CBS_BACKOFFICE_DEV,
+        REDIRECT_URI: env.REDIRECT_URI,
+        TX_AUTH_URI: env.DBUCS_TX_AUTH_URI,
+        connectedAccounts
       });
     default:
       const mockConnector = new MockConnector();
@@ -909,15 +1035,34 @@ const calculateCzechIban = (accountNumber, bankCode) => {
 };
 
 class DbuConnector extends IBankConnector {
-  constructor({ BASE_URL, USERNAME, KV }) {
+  constructor({
+    BASE_URL,
+    USERNAME,
+    KV,
+    API,
+    REDIRECT_URI,
+    TX_AUTH_URI,
+    connectedAccounts
+  }) {
     super();
     this.connectorKey = "DBU";
     this.connectedAccounts = [];
     this.baseUrl = BASE_URL;
     this.username = USERNAME;
     this.kv = KV;
+    this.api = API;
+    this.redirectUri = REDIRECT_URI;
+    this.txAuthUri = TX_AUTH_URI;
+    this.connectedAccounts = connectedAccounts;
     this.sessionId = uuidv4();
-    this.allowedPostEndpoints = ["/required-transactions", "/import/data"];
+    this.allowedPostEndpoints = [
+      "/required-transactions",
+      "/required-transactions/instant-payments",
+      "/import/data"
+    ];
+  }
+  supportsBatch(_paymentType) {
+    return false;
   }
   async makeRequest(endpoint, requestId, options = {}) {
     const { method = "GET", headers = {}, query = {}, body } = options;
@@ -927,13 +1072,11 @@ class DbuConnector extends IBankConnector {
         code: "DBU_INVALID_METHOD"
       });
     }
-    const auth = btoa("devizova_burza:Fu7psMt7i59ct43D5Y3s");
     const defaultHeaders = {
       "x-dcs-username": this.username,
       "x-dcs-session-id": `session-${this.sessionId}`,
       "x-dcs-request-id": `request-${requestId}`,
       "Content-Type": "application/json",
-      Authorization: `Basic ${auth}`,
       ...headers
     };
     const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
@@ -948,16 +1091,16 @@ class DbuConnector extends IBankConnector {
       method,
       headers: defaultHeaders
     };
-    console.log("DBU Request:", url.toString(), fetchOptions);
     if (body && method !== "GET") {
       fetchOptions.body = JSON.stringify(body);
     }
-    const response = await fetch(url.toString(), fetchOptions);
+    const response = await this.api.fetch(url.toString(), fetchOptions);
     if (!response.ok) {
+      const errorBody = await response.text().catch(() => "unable to read body");
       throw createInternalError(
         new Error(`DBU API error: ${response.status}`),
         {
-          message: `DBU request failed: ${response.statusText}`
+          message: `DBU request failed [${response.status}]: ${errorBody}`
         }
       );
     }
@@ -989,7 +1132,7 @@ class DbuConnector extends IBankConnector {
       connectorKey: "DBU",
       accountId: account.id,
       bankRefId: transaction.idRequiredTransaction.toString(),
-      amount: transaction.realizedAmount || transaction.amount,
+      amount: transaction.realizedAmount ?? transaction.amount,
       direction,
       paymentType: "DOMESTIC",
       //TODO: DBU handles domestic transactions only?
@@ -1103,41 +1246,176 @@ class DbuConnector extends IBankConnector {
     }
   }
   async getAuthUri({ ott }) {
-    throw createInternalError(null, {
-      message: "DBU connector does not require authorization",
-      code: "DBU_NO_AUTH_REQUIRED"
-    });
+    return `${this.redirectUri}?type=auth&ott=${ott}`;
   }
   async authorizeAccount({ urlParams }) {
-    return {
-      credentials: [],
-      accounts: []
+    const params = new URLSearchParams(urlParams);
+    const accountNumber = params.get("accountNumber");
+    const bankCode = params.get("bankCode");
+    const iban = params.get("iban");
+    const name = params.get("name");
+    const idAccount = params.get("idAccount");
+    if (!accountNumber || !bankCode || !iban || !idAccount) {
+      throw createInternalError(null, {
+        message: "DBU: missing required params (accountNumber, bankCode, iban, idAccount)",
+        code: "DBU_MISSING_PARAMS",
+        status: 400
+      });
+    }
+    const id = uuidv4();
+    const account = {
+      id,
+      connectorKey: "DBU",
+      status: "AUTHORIZED",
+      number: accountNumber,
+      bankCode,
+      iban,
+      name: name || `DBU ${accountNumber}`,
+      holderName: name || `DBU ${accountNumber}`,
+      countryCode: "CZ",
+      bankRefId: idAccount,
+      currency: "CZK"
     };
+    const credentials = [
+      {
+        accountId: id,
+        connectorKey: "DBU",
+        type: "API_KEY",
+        value: "dbu-tunnel-auth",
+        expiresAt: new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3)
+        // 10 years
+      }
+    ];
+    return { credentials, accounts: [account] };
   }
   async listAccounts() {
     return [];
   }
-  async initiateBatch({
-    batchId,
-    payments
-  }) {
-    throw createInternalError(null, {
-      message: "DBU batch payments not implemented yet",
-      code: "DBU_BATCH_NOT_IMPLEMENTED"
-    });
+  // ── Single payment methods ──────────────────────────────────────────
+  resolveIdAccountDebit(payment) {
+    const account = this.connectedAccounts.find(
+      (acc) => acc.id === payment.accountId
+    );
+    if (!account) {
+      throw createInternalError(null, {
+        message: `No connected account found for accountId: ${payment.accountId}`,
+        code: "DBU_ACCOUNT_NOT_FOUND"
+      });
+    }
+    return Number(account.bankRefId);
   }
-  async initiateSEPAPayment(payment) {
+  async initiateInstantPayment(payment) {
+    const body = {
+      accountNumberCredit: payment.creditor.number,
+      idAccountDebit: this.resolveIdAccountDebit(payment),
+      bankCodeCredit: payment.creditor.bankCode,
+      amount: payment.amount,
+      currencyCode: "CZK",
+      channelCode: "WWW",
+      textMessage: payment.message,
+      varSymbol: payment.vs,
+      specSymbol: payment.ss,
+      constSymbol: payment.ks,
+      uniqueExternalId: payment.id
+    };
+    const response = await this.makeRequest(
+      "/required-transactions/instant-payments",
+      payment.correlationId,
+      {
+        method: "POST",
+        body
+      }
+    );
+    const bankRefId = response.idRequiredTransaction.toString();
+    return {
+      authorizationUrl: `${this.txAuthUri}/${bankRefId}`,
+      payment: {
+        ...payment,
+        status: "PREPARED",
+        bankRefId
+      }
+    };
+  }
+  async initiateDomesticPayment(payment) {
+    if (payment.instructionPriority === "INST") {
+      return this.initiateInstantPayment(payment);
+    }
+    const body = {
+      accountNumberDebit: payment.debtor.number,
+      accountNumberCredit: payment.creditor.number,
+      bankCodeDebit: payment.debtor.bankCode,
+      bankCodeCredit: payment.creditor.bankCode,
+      amount: payment.amount,
+      currencyCode: "CZK",
+      actionTypeCode: "TRANSFER",
+      channelCode: "WWW",
+      textMessage: payment.message,
+      transactionTypeCode: "TRANSFER",
+      validFrom: format(/* @__PURE__ */ new Date(), "yyyy-MM-dd"),
+      validTo: null,
+      subEntity: "DOMESTIC",
+      partialRealization: "N",
+      forceRealization: "N",
+      varSymbol: payment.vs,
+      specSymbol: payment.ss,
+      constSymbol: payment.ks,
+      uniqueExternalId: payment.id,
+      with4EyeApproval: "Y",
+      debtorAddress: {
+        streetName: null,
+        buildingNumber: null,
+        city: null,
+        zip: null,
+        countryCode: payment.debtor.countryCode || "CZ"
+      },
+      creditorAddress: {
+        streetName: null,
+        buildingNumber: null,
+        city: null,
+        zip: null,
+        countryCode: payment.creditor.countryCode || "CZ"
+      }
+    };
+    const response = await this.makeRequest(
+      "/required-transactions",
+      payment.correlationId,
+      {
+        method: "POST",
+        body
+      }
+    );
+    const bankRefId = response.idRequiredTransaction.toString();
+    return {
+      authorizationUrl: `${this.txAuthUri}/${bankRefId}`,
+      payment: {
+        ...payment,
+        status: "PREPARED",
+        bankRefId
+      }
+    };
+  }
+  async initiateSEPAPayment(_payment) {
     throw createInternalError(null, {
-      message: "DBU SEPA payment creation not implemented yet",
+      message: "DBU SEPA payment not implemented yet",
       code: "DBU_SEPA_PAYMENT_NOT_IMPLEMENTED"
     });
   }
-  async initiateSinglePayment(payment) {
+  async initiateForeignPayment(_payment) {
     throw createInternalError(null, {
-      message: "DBU single payment creation not implemented yet",
-      code: "DBU_PAYMENT_NOT_IMPLEMENTED"
+      message: "DBU foreign payment not implemented yet",
+      code: "DBU_FOREIGN_PAYMENT_NOT_IMPLEMENTED"
     });
   }
+  // ── Batch implementation methods ─────────────────────────────────────
+  initiateDomesticBatchImpl(_args) {
+    throw new Error("DBU: Domestic batch not implemented");
+  }
+  initiateSEPABatchImpl(_args) {
+    throw new Error("DBU: SEPA batch not implemented");
+  }
+  initiateForeignBatchImpl(_args) {
+    throw new Error("DBU: Foreign batch not implemented");
+  }
   async getAllAccountPayments({
     account,
     filter
@@ -1158,7 +1436,10 @@ class DbuConnector extends IBankConnector {
           {
             method: "GET",
             query: {
+              // Filter by account
+              // 'filter.mainAccount': account.number!,
               // Date filtering
+              "filter.idAccount": account.bankRefId,
               "filter.validFromStart": dateFrom,
               "filter.validFromEnd": dateTo,
               // Pagination parameters
@@ -1172,6 +1453,8 @@ class DbuConnector extends IBankConnector {
           break;
         }
         for (const transaction of response.transactions.transaction) {
+          const status = transaction.status.trim();
+          if (status === "0" || status === "50") continue;
           try {
             const payment = this.mapDbuTransactionToPayment(
               transaction,
@@ -1188,7 +1471,6 @@ class DbuConnector extends IBankConnector {
           offset += limit;
           pageNumber += 1;
         }
-        hasMoreData = false;
       }
       return allPayments;
     } catch (error) {
@@ -1200,7 +1482,11 @@ class DbuConnector extends IBankConnector {
   async getPaymentStatus({
     paymentId
   }) {
-    return "PENDING";
+    const response = await this.makeRequest(
+      `/required-transactions/${paymentId}`,
+      uuidv4()
+    );
+    return this.mapDbuStatusToPaymentStatus(response.status);
   }
   async getBatchStatus({
     batchId
@@ -1226,9 +1512,18 @@ class ErsteConnector extends IBankConnector {
     this.ACCOUNTS_URI = config.ACCOUNTS_URI;
     this.connectedAccounts = config.connectedAccounts;
   }
-  initiateSEPAPayment(payment) {
+  initiateDomesticPayment(_payment) {
+    throw new Error("Method not implemented.");
+  }
+  initiateSEPAPayment(_payment) {
+    throw new Error("Method not implemented.");
+  }
+  initiateForeignPayment(_payment) {
     throw new Error("Method not implemented.");
   }
+  supportsBatch(paymentType) {
+    return paymentType === "DOMESTIC";
+  }
   async getAuthUri({ ott }) {
     const params = new URLSearchParams({
       redirect_uri: `${this.REDIRECT_URI}?&ott=${ott}`,
@@ -1352,7 +1647,7 @@ class ErsteConnector extends IBankConnector {
       connectorKey: "ERSTE"
     };
   }
-  async initiateBatch({
+  async initiateDomesticBatchImpl({
     batchId,
     payments
   }) {
@@ -1390,8 +1685,11 @@ class ErsteConnector extends IBankConnector {
       metadata: signInfo
     };
   }
-  initiateSinglePayment(payment) {
-    throw new Error("Method not implemented.");
+  initiateSEPABatchImpl(_args) {
+    throw new Error("Erste: SEPA batch not implemented");
+  }
+  initiateForeignBatchImpl(_args) {
+    throw new Error("Erste: Foreign batch not implemented");
   }
   async sendBatchPaymentForAuthorization(paymentIds) {
     const [data, error] = await useResult(
@@ -1525,6 +1823,9 @@ class MockCobsConnector extends FinbricksConnector {
   constructor(config) {
     super("MOCK_COBS", config);
   }
+  supportsBatch(_paymentType) {
+    return true;
+  }
 }
 
 class MockConnector extends IBankConnector {
@@ -1533,6 +1834,9 @@ class MockConnector extends IBankConnector {
     this.connectorKey = "MOCK";
     this.connectedAccounts = [];
   }
+  supportsBatch(_paymentType) {
+    return true;
+  }
   async getAuthUri({
     accountId
   }) {
@@ -1544,7 +1848,8 @@ class MockConnector extends IBankConnector {
       accounts: []
     };
   }
-  async initiateSinglePayment(payment) {
+  // ── Single payment methods ──────────────────────────────────────────
+  async initiateDomesticPayment(payment) {
     const preparedPayment = {
       ...payment,
       bankRefId: uuidv4(),
@@ -1557,9 +1862,13 @@ class MockConnector extends IBankConnector {
     };
   }
   async initiateSEPAPayment(payment) {
-    return this.initiateSinglePayment(payment);
+    return this.initiateDomesticPayment(payment);
   }
-  async initiateBatch({
+  async initiateForeignPayment(payment) {
+    return this.initiateDomesticPayment(payment);
+  }
+  // ── Batch implementation methods ─────────────────────────────────────
+  async initiateDomesticBatchImpl({
     batchId,
     payments
   }) {
@@ -1575,6 +1884,12 @@ class MockConnector extends IBankConnector {
       payments: preparedPayments
     };
   }
+  initiateSEPABatchImpl(args) {
+    return this.initiateDomesticBatchImpl(args);
+  }
+  initiateForeignBatchImpl(args) {
+    return this.initiateDomesticBatchImpl(args);
+  }
   async getAllAccountPayments({
     account: _account,
     filter: _filter