@develit-services/bank 0.3.60 → 0.4.0

package/dist/shared/{bank.CNEv3Rac.cjs → bank.CfSZTfWS.cjs}

@@ -2,37 +2,70 @@
 
 const backendSdk = require('@develit-io/backend-sdk');
 const dateFns = require('date-fns');
-const database_schema = require('./bank.CMbfx0u7.cjs');
-const drizzleOrm = require('drizzle-orm');
+const generalCodes = require('@develit-io/general-codes');
+require('./bank.BeIpkWR-.cjs');
+require('drizzle-orm');
 const jose = require('jose');
-require('@develit-io/general-codes');
 require('node:crypto');
 
 class IBankConnector {
 }
 
-const mapReferencesToPayment = (reference) => {
-  const symbols = {
-    vs: void 0,
-    ss: void 0,
-    ks: void 0
+function toIncomingPayment(input) {
+  return {
+    id: backendSdk.uuidv4(),
+    correlationId: input.correlationId,
+    refId: input.refId,
+    amount: input.amount,
+    direction: "OUTGOING",
+    paymentType: input.paymentType,
+    currency: input.currency,
+    status: "CREATED",
+    statusReason: null,
+    batchId: null,
+    initiatedAt: null,
+    // Will be set in preparePayment when sent to bank
+    processedAt: null,
+    vs: input.vs || null,
+    ss: input.ss || null,
+    ks: input.ks || null,
+    message: input.message || null,
+    creditor: input.creditor,
+    creditorIban: input.creditor.iban || null,
+    debtor: input.debtor,
+    debtorIban: input.debtor.iban || null,
+    sendAsSinglePayment: input.sendAsSinglePayment
   };
-  if (!reference) return symbols;
-  if (Array.isArray(reference) && reference.length > 0) {
-    symbols.vs = reference.find((ref) => ref.includes("VS")) || void 0;
-    symbols.ss = reference.find((ref) => ref.includes("SS")) || void 0;
-    symbols.ks = reference.find((ref) => ref.includes("KS")) || void 0;
-  }
-  if (typeof reference === "string") {
-    const vsMatch = reference.match(/VS[:\s]*(\d+)/i);
-    const ssMatch = reference.match(/SS[:\s]*(\d+)/i);
-    const ksMatch = reference.match(/KS[:\s]*(\d+)/i);
-    if (vsMatch) symbols.vs = vsMatch[1];
-    if (ssMatch) symbols.ss = ssMatch[1];
-    if (ksMatch) symbols.ks = ksMatch[1];
-  }
-  return symbols;
-};
+}
+function assignAccount(payment, account) {
+  return {
+    ...payment,
+    accountId: account.id,
+    connectorKey: account.connectorKey
+  };
+}
+function toBatchedPayment(payment) {
+  return payment;
+}
+function toPreparedPayment(payment, bankRefId, initiatedAt) {
+  return {
+    ...payment,
+    status: "PREPARED",
+    bankRefId,
+    initiatedAt: initiatedAt ?? /* @__PURE__ */ new Date()
+  };
+}
+function toCompletedPayment(payment, status, bankRefId, processedAt) {
+  return {
+    ...payment,
+    bankRefId,
+    status,
+    processedAt: processedAt ?? /* @__PURE__ */ new Date()
+  };
+}
+function batchTransform(payments, transformer) {
+  return payments.map(transformer);
+}
 
 async function signFinbricksJws({
   privateKeyPem,
@@ -195,6 +228,29 @@ const mapFinbricksAccountInsert = ({
   iban: account.identification.iban
 });
 
+const mapReferencesToPayment = (reference) => {
+  const symbols = {
+    vs: void 0,
+    ss: void 0,
+    ks: void 0
+  };
+  if (!reference) return symbols;
+  if (Array.isArray(reference) && reference.length > 0) {
+    symbols.vs = reference.find((ref) => ref.includes("VS")) || void 0;
+    symbols.ss = reference.find((ref) => ref.includes("SS")) || void 0;
+    symbols.ks = reference.find((ref) => ref.includes("KS")) || void 0;
+  }
+  if (typeof reference === "string") {
+    const vsMatch = reference.match(/VS[:\s]*(\d+)/i);
+    const ssMatch = reference.match(/SS[:\s]*(\d+)/i);
+    const ksMatch = reference.match(/KS[:\s]*(\d+)/i);
+    if (vsMatch) symbols.vs = vsMatch[1];
+    if (ssMatch) symbols.ss = ssMatch[1];
+    if (ksMatch) symbols.ks = ksMatch[1];
+  }
+  return symbols;
+};
+
 const mapFinbricksTransactionToPayment = (tx, account) => {
   const isIncoming = tx.creditDebitIndicator === "CRDT";
   const related = tx.entryDetails?.transactionDetails?.relatedParties;
@@ -332,9 +388,6 @@ class FinbricksConnector extends IBankConnector {
       )
     };
   }
-  async authenticate(code) {
-    return "";
-  }
   async revokeAuthentication(clientId) {
     const [_, error] = await backendSdk.useResult(
       this.finbricks.request({
@@ -401,45 +454,7 @@ class FinbricksConnector extends IBankConnector {
     }
     return response.accounts;
   }
-  async listAccounts() {
-    const accounts = (await Promise.all(
-      this.connectedAccounts.map(
-        (acc) => this.getAccountsForClient({ clientId: acc.token })
-      )
-    )).flat();
-    const uniqueAccounts = Array.from(
-      new Map(accounts.map((acc) => [acc.identification.iban, acc])).values()
-    );
-    return uniqueAccounts.map((acc) => ({
-      connectorKey: this.connectorKey,
-      bankRefId: acc.id,
-      currency: acc.currency,
-      sync: false,
-      status: "AUTHORIZED",
-      countryCode: acc.servicer.countryCode,
-      bankCode: acc.servicer.bankCode,
-      number: acc.identification.accountNumber.split("/")[0],
-      name: acc.productName,
-      iban: acc.identification.iban,
-      holderName: acc.ownersNames.join(", ")
-    }));
-  }
-  async preparePayment(payment) {
-    return {
-      ...payment,
-      bankRefId: backendSdk.uuidv4(),
-      // merchantTransactionId
-      direction: "OUTGOING",
-      paymentType: payment.paymentType,
-      status: "PREPARED",
-      initiatedAt: /* @__PURE__ */ new Date(),
-      accountId: this.connectedAccounts.find(
-        (acc) => acc.iban === payment.debtorIban
-      ).id,
-      connectorKey: this.PROVIDER
-    };
-  }
-  async initiateBatchFromPayments({
+  async initiateBatch({
     batchId,
     payments
   }) {
@@ -463,7 +478,7 @@ class FinbricksConnector extends IBankConnector {
             merchantBatchId: batchId
           },
           payments: payments.map((p) => ({
-            merchantTransactionId: p.bankRefId,
+            merchantTransactionId: p.id,
             creditorAccountIban: p.creditor.iban,
             amount: p.amount,
             variableSymbol: p.vs,
@@ -479,10 +494,13 @@ class FinbricksConnector extends IBankConnector {
       console.error("FINBRICKS BATCH ERROR", error);
       throw backendSdk.createInternalError(error);
     }
+    const initiatedAt = /* @__PURE__ */ new Date();
     return {
       id: batchId,
       authorizationUrls: [response.redirectUrl],
-      payments: payments.map((p) => ({ ...p, status: "INITIALIZED" }))
+      payments: payments.map(
+        (p) => toPreparedPayment(p, void 0, initiatedAt)
+      )
     };
   }
   async initiateForeignPayment(payment) {
@@ -538,7 +556,8 @@ class FinbricksConnector extends IBankConnector {
       payment: {
         ...payment,
         bankRefId,
-        status: "INITIALIZED",
+        status: "PREPARED",
+        initiatedAt: /* @__PURE__ */ new Date(),
         accountId: this.connectedAccounts.find(
           (acc) => acc.iban === payment.debtorIban
         ).id,
@@ -588,7 +607,8 @@ class FinbricksConnector extends IBankConnector {
       payment: {
         ...payment,
         bankRefId,
-        status: "INITIALIZED",
+        status: "PREPARED",
+        initiatedAt: /* @__PURE__ */ new Date(),
         accountId: this.connectedAccounts.find(
           (acc) => acc.iban === payment.debtorIban
         ).id,
@@ -603,7 +623,7 @@ class FinbricksConnector extends IBankConnector {
         method: "POST",
         body: {
           merchantId: this.finbricks.MERCHANT_ID,
-          merchantTransactionId: payment.bankRefId,
+          merchantTransactionId: payment.id,
           totalPrice: payment.amount,
           debtorAccountIban: payment.debtor.iban,
           creditorAccountIban: payment.creditor.iban,
@@ -624,7 +644,11 @@ class FinbricksConnector extends IBankConnector {
     }
     return {
       authorizationUrl: response.redirectUrl,
-      payment: { ...payment, status: "INITIALIZED" }
+      payment: {
+        ...payment,
+        status: "PREPARED",
+        initiatedAt: /* @__PURE__ */ new Date()
+      }
     };
   }
   async getAllAccountPayments({
@@ -726,6 +750,36 @@ class FinbricksConnector extends IBankConnector {
   }
 }
 
+class CreditasConnector extends FinbricksConnector {
+  constructor(config) {
+    super("CREDITAS", config);
+  }
+}
+
+class FioConnector extends FinbricksConnector {
+  constructor(config) {
+    super("FIO", config);
+  }
+}
+
+class AirBankConnector extends FinbricksConnector {
+  constructor(config) {
+    super("AIRBANK", config);
+  }
+}
+
+class CSASConnector extends FinbricksConnector {
+  constructor(config) {
+    super("CSAS", config);
+  }
+}
+
+class MonetaConnector extends FinbricksConnector {
+  constructor(config) {
+    super("MONETA", config);
+  }
+}
+
 const isDeposit = (payment, creditorIban) => {
   return payment.creditor.iban === creditorIban;
 };
@@ -734,6 +788,414 @@ const getPaymentDirection = (payment, iban) => {
   return "OUTGOING";
 };
 
+const initiateConnector = ({
+  bank,
+  env,
+  connectedAccounts
+}) => {
+  switch (bank) {
+    case "ERSTE":
+      return new ErsteConnector({
+        API_KEY: env.ERSTE_API_KEY,
+        CLIENT_ID: env.ERSTE_CLIENT_ID,
+        CLIENT_SECRET: env.ERSTE_CLIENT_SECRET,
+        REDIRECT_URI: env.REDIRECT_URI,
+        AUTH_URI: env.ERSTE_AUTH_URI,
+        PAYMENTS_URI: env.ERSTE_PAYMENTS_URI,
+        ACCOUNTS_URI: env.ERSTE_ACCOUNTS_URI,
+        connectedAccounts
+      });
+    case "CREDITAS":
+      return new CreditasConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "MOCK_COBS":
+      return new MockCobsConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "FIO":
+      return new FioConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "MONETA":
+      return new MonetaConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "AIRBANK":
+      return new AirBankConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "CSAS":
+      return new CSASConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "DBU":
+      return new DbuConnector({
+        BASE_URL: env.DBUCS_BASE_URI,
+        USERNAME: env.DBUCS_USERNAME,
+        KV: env.BANK_KV
+      });
+    default:
+      const mockConnector = new MockConnector();
+      mockConnector.connectedAccounts = connectedAccounts;
+      return mockConnector;
+  }
+};
+function mod97(string) {
+  let checksum = string.slice(0, 2);
+  let fragment = "";
+  for (let offset = 2; offset < string.length; offset += 7) {
+    fragment = checksum + string.substring(offset, offset + 7);
+    checksum = (parseInt(fragment, 10) % 97).toString();
+  }
+  return parseInt(checksum, 10);
+}
+const calculateCzechIban = (accountNumber, bankCode) => {
+  const paddedBankCode = bankCode.padStart(4, "0");
+  let prefix = "";
+  let mainAccount = accountNumber;
+  if (accountNumber.includes("-")) {
+    const parts = accountNumber.split("-");
+    prefix = parts[0];
+    mainAccount = parts[1];
+  }
+  const paddedPrefix = prefix.padStart(6, "0");
+  const paddedAccount = mainAccount.padStart(10, "0");
+  const basicIban = paddedBankCode + paddedPrefix + paddedAccount;
+  const rearranged = basicIban + "1215";
+  const remainder = mod97(rearranged);
+  const checkDigits = (98 - remainder).toString().padStart(2, "0");
+  return `CZ${checkDigits}${basicIban}`;
+};
+
+class DbuConnector extends IBankConnector {
+  constructor({ BASE_URL, USERNAME, KV }) {
+    super();
+    this.connectorKey = "DBU";
+    this.connectedAccounts = [];
+    this.baseUrl = BASE_URL;
+    this.username = USERNAME;
+    this.kv = KV;
+    this.sessionId = backendSdk.uuidv4();
+    this.allowedPostEndpoints = ["/required-transactions", "/import/data"];
+  }
+  async makeRequest(endpoint, requestId, options = {}) {
+    const { method = "GET", headers = {}, query = {}, body } = options;
+    if (method === "POST" && !this.allowedPostEndpoints.includes(endpoint)) {
+      throw backendSdk.createInternalError(null, {
+        message: `DBU API endpoint ${endpoint} does not support POST method`,
+        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;
+    const cleanEndpoint = endpoint.startsWith("/") ? endpoint.slice(1) : endpoint;
+    const url = new URL(`${baseUrl}/${cleanEndpoint}`);
+    Object.entries(query).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        url.searchParams.append(key, value);
+      }
+    });
+    const fetchOptions = {
+      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);
+    if (!response.ok) {
+      throw backendSdk.createInternalError(
+        new Error(`DBU API error: ${response.status}`),
+        {
+          message: `DBU request failed: ${response.statusText}`
+        }
+      );
+    }
+    return response.json();
+  }
+  mapDbuCurrencyCode(dbuCurrency) {
+    const currency = dbuCurrency.toUpperCase();
+    if (generalCodes.CURRENCY_CODES.includes(currency))
+      return currency;
+    throw backendSdk.createInternalError(null, {
+      message: `Unknown DBU currency code: ${dbuCurrency}`,
+      code: "DBU_UNKNOWN_CURRENCY"
+    });
+  }
+  mapDbuTransactionToPayment(transaction, account) {
+    const isIncoming = transaction.accountNumberCredit === account.number;
+    const direction = isIncoming ? "INCOMING" : "OUTGOING";
+    const creditorIban = calculateCzechIban(
+      transaction.accountNumberCredit,
+      transaction.bankCodeCredit
+    );
+    const debtorIban = calculateCzechIban(
+      transaction.accountNumberDebit,
+      transaction.bankCodeDebit
+    );
+    const parsed = {
+      id: backendSdk.uuidv4(),
+      correlationId: backendSdk.uuidv4(),
+      connectorKey: "DBU",
+      accountId: account.id,
+      bankRefId: transaction.idRequiredTransaction.toString(),
+      amount: transaction.realizedAmount || transaction.amount,
+      direction,
+      paymentType: "DOMESTIC",
+      //TODO: DBU handles domestic transactions only?
+      currency: this.mapDbuCurrencyCode(transaction.currencyCode),
+      status: this.mapDbuStatusToPaymentStatus(transaction.status),
+      initiatedAt: transaction.validFrom ? new Date(transaction.validFrom) : /* @__PURE__ */ new Date(),
+      processedAt: transaction.realizationDate ? new Date(transaction.realizationDate) : null,
+      vs: transaction.varSymbol,
+      ss: transaction.specSymbol,
+      ks: transaction.constSymbol,
+      message: transaction.textMessage,
+      creditor: {
+        number: transaction.accountNumberCredit,
+        bankCode: transaction.bankCodeCredit,
+        iban: creditorIban
+      },
+      debtor: {
+        number: transaction.accountNumberDebit,
+        bankCode: transaction.bankCodeDebit,
+        iban: debtorIban
+      },
+      debtorIban
+    };
+    return {
+      raw: transaction,
+      parsed
+    };
+  }
+  mapDbuStatusToPaymentStatus(dbuStatus) {
+    const statusCode = dbuStatus.trim();
+    switch (statusCode) {
+      // COMPLETED - Transaction is fully realized
+      case "3":
+        return "COMPLETED";
+      // PREPARED - Transaction is new and ready for processing
+      case "0":
+        return "PREPARED";
+      // PENDING - Transaction is partially processed or on hold
+      case "1":
+      // RQT_STATUS_READY_FOR_REAL
+      case "2":
+      // RQT_STATUS_PARTIAL_REALIZED
+      case "4":
+      // RQT_STATUS_PARTIAL_HOLDED
+      case "5":
+      // RQT_STATUS_HOLDED
+      case "6":
+      // RQT_STATUS_WAIT_FOR_COT
+      case "11":
+      // RQT_STATUS_UNHOLDED
+      case "30":
+      // RQT_STATUS_RQ_TO_HD
+      case "31":
+      // RQT_STATUS_RQ_TO_HD_SENT
+      case "32":
+      // RQT_STATUS_WAIT_TO_HD_VERIFY
+      case "34":
+      // RQT_STATUS_HD_NEW_COLLECTION
+      case "35":
+      // RQT_STATUS_HD_RQ_COLLECTION
+      case "40":
+      // RQT_STATUS_SIPO_CHARGE
+      case "50":
+      // RQT_STATUS_4E
+      case "51":
+      // RQT_STATUS_4E_EDIT
+      case "60":
+      // RQT_STATUS_READY_TO_CANCELLED
+      case "61":
+      // RQT_STATUS_READY_TO_UNHOLDED
+      case "63":
+      // RQT_STATUS_READY_TO_REVERTED
+      case "64":
+      // RQT_STATUS_CC_CREATED
+      case "65":
+      // RQT_STATUS_CC_WAIT_FOR_RATE
+      case "66":
+      // RQT_STATUS_WAIT_FOR_DEBTOR
+      case "70":
+      // RQT_STATUS_RQ_TO_SEPA
+      case "71":
+      // RQT_STATUS_RQ_TO_SEPA_SENT
+      case "72":
+      // RQT_STATUS_RQ_TO_SEPA_CNC
+      case "73":
+      // RQT_STATUS_RQ_TO_SEPA_CNC_URG
+      case "74":
+      // RQT_STATUS_RQ_TO_SEPA_CNC_CLIENT
+      case "75":
+      // RQT_STATUS_RQ_TO_SEPA_056
+      case "80":
+        return "PENDING";
+      // FAILED - Transaction is cancelled, rejected, reverted, suspended or expired
+      case "10":
+      // RQT_STATUS_CANCELLED
+      case "12":
+      // RQT_STATUS_SUSPENDED
+      case "13":
+      // RQT_STATUS_REVERTED
+      case "14":
+      // RQT_STATUS_EXPIRED
+      case "15":
+      // RQT_STATUS_REJECTED
+      case "33":
+      // RQT_STATUS_HD_CANCELLED
+      case "39":
+        return "FAILED";
+      // Default to PENDING for unknown status codes
+      default:
+        return "PENDING";
+    }
+  }
+  async getAuthUri({ ott }) {
+    throw backendSdk.createInternalError(null, {
+      message: "DBU connector does not require authorization",
+      code: "DBU_NO_AUTH_REQUIRED"
+    });
+  }
+  async authorizeAccount({ urlParams }) {
+    return {
+      credentials: [],
+      accounts: []
+    };
+  }
+  async listAccounts() {
+    return [];
+  }
+  async initiateBatch({
+    batchId,
+    payments
+  }) {
+    throw backendSdk.createInternalError(null, {
+      message: "DBU batch payments not implemented yet",
+      code: "DBU_BATCH_NOT_IMPLEMENTED"
+    });
+  }
+  async initiateSEPAPayment(payment) {
+    throw backendSdk.createInternalError(null, {
+      message: "DBU SEPA payment creation not implemented yet",
+      code: "DBU_SEPA_PAYMENT_NOT_IMPLEMENTED"
+    });
+  }
+  async initiateSinglePayment(payment) {
+    throw backendSdk.createInternalError(null, {
+      message: "DBU single payment creation not implemented yet",
+      code: "DBU_PAYMENT_NOT_IMPLEMENTED"
+    });
+  }
+  async getAllAccountPayments({
+    account,
+    filter
+  }) {
+    try {
+      const dateFrom = dateFns.format(filter.dateFrom, "yyyy-MM-dd");
+      const dateTo = dateFns.format(filter.dateTo || /* @__PURE__ */ new Date(), "yyyy-MM-dd");
+      const allPayments = [];
+      let offset = 0;
+      const limit = 10;
+      let hasMoreData = true;
+      let pageNumber = 1;
+      const baseRequestId = backendSdk.uuidv4();
+      while (hasMoreData) {
+        const response = await this.makeRequest(
+          "/required-transactions",
+          `${baseRequestId}_page${pageNumber}`,
+          {
+            method: "GET",
+            query: {
+              // Date filtering
+              "filter.validFromStart": dateFrom,
+              "filter.validFromEnd": dateTo,
+              // Pagination parameters
+              offset: offset.toString(),
+              limit: limit.toString()
+            }
+          }
+        );
+        if (!response.transactions?.transaction || response.transactions.transaction.length === 0) {
+          hasMoreData = false;
+          break;
+        }
+        for (const transaction of response.transactions.transaction) {
+          try {
+            const payment = this.mapDbuTransactionToPayment(
+              transaction,
+              account
+            );
+            allPayments.push(payment);
+          } catch (error) {
+            console.error("Failed to map DBU transaction:", error, transaction);
+          }
+        }
+        if (response.transactions.transaction.length < limit) {
+          hasMoreData = false;
+        } else {
+          offset += limit;
+          pageNumber += 1;
+        }
+        hasMoreData = false;
+      }
+      return allPayments;
+    } catch (error) {
+      throw backendSdk.createInternalError(error, {
+        message: "Failed to fetch payments from DBU API"
+      });
+    }
+  }
+  async getPaymentStatus({
+    paymentId
+  }) {
+    return "PENDING";
+  }
+  async getBatchStatus({
+    batchId
+  }) {
+    return {
+      status: "OPEN",
+      apiResponse: {}
+    };
+  }
+}
+
 class ErsteConnector extends IBankConnector {
   constructor(config) {
     super();
@@ -782,40 +1244,49 @@ class ErsteConnector extends IBankConnector {
       ]
     };
   }
-  async authenticate(tokens) {
-    const grantType = tokens?.refreshToken ? "refresh_token" : "authorization_code";
-    let bodyParams = {
-      client_id: this.CLIENT_ID,
-      client_secret: this.CLIENT_SECRET,
-      grant_type: grantType
-    };
-    if (tokens?.token) {
-      bodyParams = {
-        ...bodyParams,
-        code: tokens.token,
-        redirect_uri: this.REDIRECT_URI
-      };
-    }
-    if (tokens?.refreshToken) bodyParams.refresh_token = tokens?.refreshToken;
-    const body = new URLSearchParams(bodyParams);
-    const result = await fetch(`${this.AUTH_URI}/token`, {
-      method: "POST",
-      body: body.toString(),
-      headers: { "Content-Type": "application/x-www-form-urlencoded" }
-    });
-    if (result.status !== 200) {
-      throw backendSdk.createInternalError(null, {
-        message: await result.text()
-      });
-    }
-    const json = await result.json();
-    this.accessToken = json.access_token;
-    return json.refresh_token || "";
-  }
-  listAccounts() {
-    throw new Error("Method not implemented.");
-  }
-  async preparePayment(payment) {
+  // async authenticate(tokens?: {
+  //   refreshToken?: string
+  //   token?: string
+  // }): Promise<string> {
+  //   const grantType = tokens?.refreshToken
+  //     ? 'refresh_token'
+  //     : 'authorization_code'
+  //   let bodyParams: Record<string, string> = {
+  //     client_id: this.CLIENT_ID!,
+  //     client_secret: this.CLIENT_SECRET!,
+  //     grant_type: grantType,
+  //   }
+  //   if (tokens?.token) {
+  //     bodyParams = {
+  //       ...bodyParams,
+  //       code: tokens.token,
+  //       redirect_uri: this.REDIRECT_URI,
+  //     }
+  //   }
+  //   if (tokens?.refreshToken) bodyParams.refresh_token = tokens?.refreshToken
+  //   const body = new URLSearchParams(bodyParams)
+  //   const result = await fetch(`${this.AUTH_URI}/token`, {
+  //     method: 'POST',
+  //     body: body.toString(),
+  //     headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+  //   })
+  //   if (result.status !== 200) {
+  //     throw createInternalError(null, {
+  //       message: await result.text(),
+  //     })
+  //   }
+  //   const json = (await result.json()) as {
+  //     access_token: string
+  //     refresh_token?: string
+  //   }
+  //   this.accessToken = json.access_token
+  //   return json.refresh_token || ''
+  // }
+  /**
+   * Erste-specific: Prepare individual payment
+   * This is an internal method used by initiateBatch
+   */
+  async prepareErstePayment(payment) {
     if (!this.accessToken) {
       throw backendSdk.createInternalError(null, {
         message: "Internal authentication failed",
@@ -865,14 +1336,19 @@ class ErsteConnector extends IBankConnector {
       connectorKey: "ERSTE"
     };
   }
-  async initiateBatchFromPayments({
+  async initiateBatch({
     batchId,
     payments
   }) {
-    const allRefIds = payments.map((payment) => payment.bankRefId);
+    const preparedPayments = [];
+    for (const payment of payments) {
+      const prepared = await this.prepareErstePayment(payment);
+      preparedPayments.push(prepared);
+    }
+    const allRefIds = preparedPayments.map((payment) => payment.bankRefId);
     if (allRefIds.length === 0) {
       throw backendSdk.createInternalError(null, {
-        message: "No valid payments to include in batch",
+        message: "No payments to include in batch",
         status: 400
       });
     }
@@ -883,7 +1359,10 @@ class ErsteConnector extends IBankConnector {
       throw backendSdk.createInternalError(signError);
     }
     const [authUri, authUriError] = await backendSdk.useResult(
-      this.getBatchAuthorizationURI(signInfo)
+      this.getBatchAuthorizationURI({
+        signHash: signInfo.signHash,
+        signId: signInfo.signId
+      })
     );
     if (authUriError) {
       throw backendSdk.createInternalError(authUriError);
@@ -891,14 +1370,11 @@ class ErsteConnector extends IBankConnector {
     return {
       id: batchId,
       authorizationUrls: [authUri || ""],
-      payments: payments.map((payment) => ({
-        ...payment,
-        status: "INITIALIZED"
-      })),
+      payments: preparedPayments,
       metadata: signInfo
     };
   }
-  initiateSinglePayment() {
+  initiateSinglePayment(payment) {
     throw new Error("Method not implemented.");
   }
   async sendBatchPaymentForAuthorization(paymentIds) {
@@ -1029,21 +1505,18 @@ class ErsteConnector extends IBankConnector {
   }
 }
 
+class MockCobsConnector extends FinbricksConnector {
+  constructor(config) {
+    super("MOCK_COBS", config);
+  }
+}
+
 class MockConnector extends IBankConnector {
   constructor() {
     super();
     this.connectorKey = "MOCK";
     this.connectedAccounts = [];
   }
-  initiateSEPAPayment(payment) {
-    throw new Error("Method not implemented.");
-  }
-  async authenticate() {
-    return "";
-  }
-  async listAccounts() {
-    return [];
-  }
   async getAuthUri({
     accountId
   }) {
@@ -1055,79 +1528,55 @@ class MockConnector extends IBankConnector {
       accounts: []
     };
   }
-  async preparePayment(payment) {
-    const bankRefId = backendSdk.uuidv4();
-    return {
+  async initiateSinglePayment(payment) {
+    const preparedPayment = {
       ...payment,
-      id: backendSdk.uuidv4(),
-      bankRefId,
-      direction: "OUTGOING",
-      paymentType: "DOMESTIC",
+      bankRefId: backendSdk.uuidv4(),
       status: "PREPARED",
-      initiatedAt: /* @__PURE__ */ new Date(),
-      accountId: this.connectedAccounts.find(
-        (acc) => acc.iban === payment.debtor.iban
-      ).id,
-      connectorKey: "MOCK"
+      initiatedAt: /* @__PURE__ */ new Date()
     };
-  }
-  async initiateSinglePayment(payment) {
     return {
-      payment: {
-        ...payment,
-        status: "INITIALIZED"
-      },
-      authorizationUrl: "http://mock.com"
+      payment: preparedPayment,
+      authorizationUrl: "http://mock.com/auto-approve"
     };
   }
-  async initiateBatchFromPayments({
+  async initiateSEPAPayment(payment) {
+    return this.initiateSinglePayment(payment);
+  }
+  async initiateBatch({
     batchId,
     payments
   }) {
+    const preparedPayments = payments.map((payment) => ({
+      ...payment,
+      bankRefId: backendSdk.uuidv4(),
+      status: "PREPARED",
+      initiatedAt: /* @__PURE__ */ new Date()
+    }));
     return {
-      id: backendSdk.uuidv4(),
-      authorizationUrls: ["http://mock.com"],
-      payments: payments.map(
-        (payment) => ({
-          ...payment,
-          status: "INITIALIZED"
-        })
-      )
+      id: batchId,
+      authorizationUrls: ["http://mock.com/auto-approve"],
+      payments: preparedPayments
     };
   }
   async getAllAccountPayments({
-    db
+    account,
+    filter
   }) {
-    const payments = await db.select().from(tables.payment).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(tables.payment.status, "INITIALIZED"),
-        drizzleOrm.eq(tables.payment.direction, "OUTGOING")
-      )
-    );
-    return payments.map((payment) => ({
-      raw: payment,
-      parsed: {
-        ...payment,
-        status: "COMPLETED"
-      }
-    }));
-  }
-  getPaymentStatus(_) {
-    throw new Error("Method not implemented.");
+    return [];
   }
-  getBatchStatus(_) {
-    throw new Error("Method not implemented.");
+  async getPaymentStatus(_) {
+    return "COMPLETED";
   }
-}
-
-class MockCobsConnector extends FinbricksConnector {
-  constructor(config) {
-    super("MOCK_COBS", config);
+  async getBatchStatus(_) {
+    return {
+      status: "SIGNED",
+      apiResponse: { mock: true }
+    };
   }
 }
 
-const tables = database_schema.schema;
-
+exports.DbuConnector = DbuConnector;
 exports.ErsteConnector = ErsteConnector;
 exports.FINBRICKS_ENDPOINTS = FINBRICKS_ENDPOINTS;
 exports.FinbricksClient = FinbricksClient;
@@ -1135,6 +1584,12 @@ exports.FinbricksConnector = FinbricksConnector;
 exports.IBankConnector = IBankConnector;
 exports.MockCobsConnector = MockCobsConnector;
 exports.MockConnector = MockConnector;
+exports.assignAccount = assignAccount;
+exports.batchTransform = batchTransform;
+exports.initiateConnector = initiateConnector;
 exports.signFinbricksJws = signFinbricksJws;
-exports.tables = tables;
+exports.toBatchedPayment = toBatchedPayment;
+exports.toCompletedPayment = toCompletedPayment;
+exports.toIncomingPayment = toIncomingPayment;
+exports.toPreparedPayment = toPreparedPayment;
 exports.useFinbricksFetch = useFinbricksFetch;