@develit-services/bank 0.0.13 → 0.0.15

package/dist/shared/{bank.TOYdvcg7.mjs → bank.DZS4d3MJ.mjs}

@@ -1,10 +1,11 @@
-import { createInternalError, useResult, uuidv4 } from '@develit-io/backend-sdk';
+import { uuidv4, useResult, createInternalError } from '@develit-io/backend-sdk';
 import { s as schema } from './bank.BeH-ZCJJ.mjs';
 import { and, eq } from 'drizzle-orm';
-import { format, parseISO } from 'date-fns';
-import { importPKCS8, SignJWT } from 'jose';
-import { COUNTRY_CODES_2, CURRENCY_CODES } from '@develit-io/general-codes';
 import { z } from 'zod';
+import { COUNTRY_CODES_2, CURRENCY_CODES } from '@develit-io/general-codes';
+import { importPKCS8, SignJWT } from 'jose';
+import 'superjson';
+import { format, parseISO } from 'date-fns';
 
 const tables = schema;
 
@@ -32,12 +33,102 @@ const COUNTRY_CODES = COUNTRY_CODES_2;
 class IBankConnector {
 }
 
-const isDeposit = (payment, creditorIban) => {
-  return payment.creditorIban === creditorIban;
+async function signFinbricksJws({
+  privateKeyPem,
+  merchantId,
+  jwsData
+}) {
+  const privateKey = await importPKCS8(privateKeyPem, "RS256");
+  const payload = JSON.stringify(jwsData);
+  const jws = await new SignJWT(JSON.parse(payload)).setProtectedHeader({
+    alg: "RS256",
+    kid: merchantId,
+    typ: "JWT"
+  }).sign(privateKey);
+  const [header, , signature] = jws.split(".");
+  return `${header}..${signature}`;
+}
+
+const useFinbricksFetch = async (config, init) => {
+  const {
+    baseUrl,
+    endpoint,
+    method = "GET",
+    merchantId,
+    privateKeyPem,
+    query,
+    body,
+    correlationId,
+    psuIp = "88.205.47.1",
+    psuAgent = "Develit/BankService"
+  } = config;
+  const url = new URL(`${baseUrl}${endpoint}`);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0 && v !== null)
+        url.searchParams.append(k, v.toString());
+    }
+  }
+  const uriWithQuery = `${endpoint}${url.search ? `?${url.searchParams.toString()}` : ""}`;
+  const bodyString = body ? JSON.stringify(body) : "";
+  const jwsSignature = await signFinbricksJws({
+    privateKeyPem,
+    merchantId,
+    jwsData: {
+      uri: uriWithQuery,
+      body: bodyString
+    }
+  });
+  const headers = {
+    "Content-Type": "application/json",
+    "JWS-Signature": jwsSignature,
+    "PSU-IP-Address": psuIp,
+    "PSU-User-Agent": psuAgent,
+    ...init?.headers
+  };
+  if (correlationId) {
+    headers["Correlation-ID"] = correlationId;
+  }
+  const res = await fetch(url.toString(), {
+    method,
+    headers,
+    body: method !== "GET" ? bodyString : void 0
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "unknown error");
+    throw new Error(
+      `Finbricks API error: ${res.status} ${res.statusText} \u2013 ${text}`
+    );
+  }
+  return await res.json();
 };
-const getPaymentDirection = (payment, iban) => {
-  if (isDeposit(payment, iban)) return "INCOMING";
-  return "OUTGOING";
+class FinbricksClient {
+  constructor(baseUrl, merchantId, privateKeyPem) {
+    this.BASE_URL = baseUrl;
+    this.MERCHANT_ID = merchantId;
+    this.PRIVATE_KEY_PEM = privateKeyPem;
+  }
+  async request(params) {
+    return useFinbricksFetch({
+      baseUrl: this.BASE_URL,
+      merchantId: this.MERCHANT_ID,
+      privateKeyPem: this.PRIVATE_KEY_PEM,
+      ...params
+    });
+  }
+}
+
+const FINBRICKS_ENDPOINTS = {
+  AUTHENTICATE_V2: "/v2/auth/authenticate",
+  AUTH_TOKEN_STATUS: "/auth/token",
+  AUTH_TOKEN_REVOKE: "/auth/revoke",
+  ACCOUNT_LIST: "/account/list",
+  ACCOUNT_BALANCE: "/account/balance",
+  ACCOUNT_TRANSACTIONS: "/account/transactions",
+  TRANSACTION_INIT: "/transaction/platform/init",
+  TRANSACTION_STATUS: "/transaction/platform/status",
+  TRANSACTION_BATCH_INIT: "/transaction/platform/batchPayment/init",
+  BATCH_STATUS: "/transaction/platform/batchPayment/status"
 };
 
 const mapReferencesToPayment = (reference) => {
@@ -63,6 +154,376 @@ const mapReferencesToPayment = (reference) => {
   return symbols;
 };
 
+const mapFinbricksStatus = (status) => {
+  switch (status) {
+    case "BOOK":
+      return "COMPLETED";
+    case "PDNG":
+      return "PENDING";
+    case "CANCL":
+      return "FAILED";
+    case "RJCT":
+      return "FAILED";
+    case "SCHDL":
+      return "PENDING";
+    case "HOLD":
+      return "PENDING";
+    case "INFO":
+      return "PENDING";
+    default:
+      return "PENDING";
+  }
+};
+const mapFinbricksTransactionStatus = (status) => {
+  switch (status) {
+    case "OPENED":
+      return "CREATED";
+    case "AUTHORIZED":
+      return "PENDING";
+    case "COMPLETED":
+      return "COMPLETED";
+    case "BOOKED":
+      return "PENDING";
+    case "SETTLED":
+      return "COMPLETED";
+    case "REJECTED":
+      return "FAILED";
+    case "CLOSED":
+      return "FAILED";
+  }
+};
+const mapFinbricksBatchStatus = (status) => {
+  return status === "REJECTED" ? "FAILED" : status === "AUTHORIZED" ? "PROCESSING" : "READY_TO_SIGN";
+};
+const mapFinbricksTransactionToPayment = (tx, account) => {
+  const isIncoming = tx.creditDebitIndicator === "CRDT";
+  const related = tx.entryDetails.transactionDetails.relatedParties;
+  const base = {
+    id: uuidv4(),
+    bankRefId: tx.entryReference || tx.fbxReference,
+    amount: tx.amount?.value || 0,
+    currency: tx.amount?.currency || "CZK",
+    paymentType: "DOMESTIC",
+    status: mapFinbricksStatus(tx.status),
+    message: tx.entryDetails.transactionDetails.remittanceInformation?.unstructured || tx.entryDetails.transactionDetails.additionalRemittanceInformation || null,
+    processedAt: new Date(tx.bookingDate.date),
+    ...mapReferencesToPayment(
+      tx.entryDetails.transactionDetails.remittanceInformation?.structured?.creditorReferenceInformation?.reference || tx.entryDetails.transactionDetails.references?.endToEndIdentification
+    ),
+    debtorHolderName: isIncoming ? related.debtor?.name || "Unknown" : "Unknown",
+    creditorHolderName: isIncoming ? "Unknown" : related.creditor?.name || "Unknown",
+    debtorIban: isIncoming ? related.debtorAccount?.identification?.iban || account.identification.iban : account.identification.iban,
+    creditorIban: isIncoming ? account.identification.iban : related.creditorAccount?.identification?.iban || account.identification.iban,
+    direction: "INCOMING"
+    // přepíšeme správným směrem níže
+  };
+  base.direction = getPaymentDirection(base, account.identification.iban);
+  return base;
+};
+
+class FinbricksConnector extends IBankConnector {
+  constructor(provider, { BASE_URI, MERCHANT_ID, PRIVATE_KEY_PEM }) {
+    super();
+    this.connectorKey = "FINBRICKS";
+    this.PROVIDER = provider;
+    this.finbricks = new FinbricksClient(BASE_URI, MERCHANT_ID, PRIVATE_KEY_PEM);
+  }
+  static {
+    this.FETCH_INTERVAL = 60 * 60 * 5;
+  }
+  async connectUserAccount() {
+    const clientId = uuidv4();
+    const body = {
+      merchantId: this.finbricks.MERCHANT_ID,
+      clientId,
+      paymentProvider: this.PROVIDER,
+      scope: "AISP_PISP",
+      callbackUrl: "https://example.com/callback"
+    };
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        endpoint: FINBRICKS_ENDPOINTS.AUTHENTICATE_V2,
+        method: "POST",
+        body
+      })
+    );
+    if (error || !response) {
+      throw createInternalError(error, {
+        message: "Finbricks: failed to connect user"
+      });
+    }
+    return {
+      redirectUrl: response.redirectUrl,
+      clientId
+    };
+  }
+  async authenticate({ token: clientId }) {
+    if (!!clientId) {
+      const isExpired = await this.isClientIdExpired(clientId);
+      if (!isExpired) {
+        this.lastValidClientId = clientId;
+        return clientId;
+      }
+    }
+    const newClientId = uuidv4();
+    const body = {
+      merchantId: this.finbricks.MERCHANT_ID,
+      paymentProvider: this.PROVIDER,
+      clientId: newClientId,
+      scope: "AISP_PISP",
+      callbackUrl: `www.example.com/callback`
+    };
+    const [res, error] = await useResult(
+      this.finbricks.request({
+        endpoint: "/v2/auth/authenticate",
+        method: "POST",
+        body
+      })
+    );
+    if (error || !res) {
+      throw createInternalError(error, {
+        message: `Finbricks: authentication request failed (${this.PROVIDER})`
+      });
+    }
+    this.lastValidClientId = newClientId;
+    return res.redirectUrl;
+  }
+  async revokeAuthentication(clientId) {
+    const [_, error] = await useResult(
+      this.finbricks.request({
+        endpoint: FINBRICKS_ENDPOINTS.AUTH_TOKEN_REVOKE,
+        method: "DELETE",
+        query: {
+          merchantId: this.finbricks.MERCHANT_ID,
+          clientId,
+          provider: this.PROVIDER
+        }
+      })
+    );
+    if (error) {
+      throw createInternalError(error, {
+        message: `Finbricks: failed to revoke authentication for clientId ${clientId}`
+      });
+    }
+    this.lastValidClientId = "";
+  }
+  async isClientIdExpired(clientId) {
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        endpoint: FINBRICKS_ENDPOINTS.AUTH_TOKEN_STATUS,
+        method: "GET",
+        query: {
+          merchantId: this.finbricks.MERCHANT_ID,
+          clientId,
+          provider: this.PROVIDER
+        }
+      })
+    );
+    if (error) {
+      throw createInternalError(error, {
+        message: `Finbricks: failed to fetch token info for clientId: ${clientId}`
+      });
+    }
+    if (!response || response.length === 0) return true;
+    const record = response.find((token) => token.clientId === clientId);
+    if (!record) return true;
+    const validTo = new Date(record.validTo);
+    return validTo.getTime() < Date.now();
+  }
+  async listAccounts() {
+    if (!this.lastValidClientId) {
+      throw createInternalError(null, {
+        message: "Finbricks: missing valid clientId",
+        code: "FINBRICKS_CLIENT_ID_MISSING"
+      });
+    }
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        endpoint: FINBRICKS_ENDPOINTS.ACCOUNT_LIST,
+        method: "GET",
+        query: {
+          merchantId: this.finbricks.MERCHANT_ID,
+          paymentProvider: this.PROVIDER,
+          clientId: this.lastValidClientId
+        }
+      })
+    );
+    if (error || !response) {
+      throw createInternalError(error, {
+        message: "Finbricks: failed to list accounts"
+      });
+    }
+    return response.accounts;
+  }
+  async preparePayment(payment) {
+    const bankRefId = uuidv4();
+    return {
+      ...payment,
+      id: uuidv4(),
+      bankRefId,
+      direction: "OUTGOING",
+      paymentType: "DOMESTIC",
+      status: "PREPARED",
+      initiatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async initiateBatchFromPayments({
+    payments
+  }) {
+    const batchId = uuidv4();
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        endpoint: FINBRICKS_ENDPOINTS.TRANSACTION_BATCH_INIT,
+        method: "POST",
+        body: {
+          batchPaymentIdentification: {
+            merchantId: this.finbricks.MERCHANT_ID,
+            debtorAccountIban: payments[0].debtorIban,
+            clientId: this.lastValidClientId,
+            callbackUrl: "https://example.com/callback",
+            merchantBatchId: batchId
+          },
+          payments: payments.map((p) => ({
+            merchantTransactionId: p.bankRefId,
+            creditorAccountIban: p.creditorIban,
+            amount: p.amount
+          }))
+        }
+      })
+    );
+    if (error || !response) {
+      throw createInternalError(error, {
+        message: "Finbricks: failed to initiate batch payment"
+      });
+    }
+    return {
+      id: batchId,
+      authorizationUrls: [response.redirectUrl],
+      payments: payments.map((p) => ({ ...p, status: "INITIALIZED" }))
+    };
+  }
+  async initiateSinglePayment(payment) {
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        endpoint: FINBRICKS_ENDPOINTS.TRANSACTION_INIT,
+        method: "POST",
+        body: {
+          merchantId: this.finbricks.MERCHANT_ID,
+          merchantTransactionId: payment.bankRefId,
+          totalPrice: payment.amount,
+          debtorAccountIban: payment.debtorIban,
+          creditorAccountIban: payment.creditorIban,
+          creditorName: payment.creditorHolderName,
+          description: payment.message || "",
+          variableSymbol: payment.vs || "",
+          callbackUrl: "https://example.com/callback",
+          paymentProvider: this.PROVIDER
+        }
+      })
+    );
+    if (error || !response) {
+      throw createInternalError(error, {
+        message: "Finbricks: failed to initiate payment"
+      });
+    }
+    return {
+      authorizationUrl: response.redirectUrl,
+      payment: { ...payment, status: "INITIALIZED" }
+    };
+  }
+  async getAllAccountPayments({
+    account,
+    lastSync
+  }) {
+    const dateFormat = "yyyy-MM-dd";
+    const dateFrom = format(lastSync.lastSyncedAt, dateFormat);
+    const dateTo = format(/* @__PURE__ */ new Date(), dateFormat);
+    let cursor = null;
+    const allPayments = [];
+    const fetchTransactions = async (cursor2) => {
+      return useResult(
+        this.finbricks.request({
+          method: "GET",
+          endpoint: FINBRICKS_ENDPOINTS.ACCOUNT_TRANSACTIONS,
+          query: {
+            merchantId: this.finbricks.MERCHANT_ID,
+            clientId: this.lastValidClientId,
+            paymentProvider: this.PROVIDER,
+            bankAccountId: account.identification.number,
+            dateFrom,
+            dateTo,
+            currency: account.currency,
+            size: "20",
+            cursor: cursor2 ?? void 0
+          }
+        })
+      );
+    };
+    do {
+      {
+        const [response, error] = await fetchTransactions(cursor);
+        if (error || !response) {
+          throw createInternalError(error, {
+            message: "Finbricks: failed to fetch account transactions"
+          });
+        }
+        const { transactions, links } = response;
+        cursor = links?.[0]?.value || null;
+        for (const tx of transactions) {
+          allPayments.push(mapFinbricksTransactionToPayment(tx, account));
+        }
+      }
+    } while (cursor != null);
+    return allPayments;
+  }
+  async getPaymentStatus({
+    paymentId
+  }) {
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        method: "GET",
+        endpoint: FINBRICKS_ENDPOINTS.TRANSACTION_STATUS,
+        query: {
+          merchantId: this.finbricks.MERCHANT_ID,
+          merchantTransactionId: paymentId
+        }
+      })
+    );
+    if (error || !response) {
+      throw createInternalError(error, {
+        message: "Finbricks: failed to fetch payment status"
+      });
+    }
+    return mapFinbricksTransactionStatus(response.resultCode);
+  }
+  async getBatchStatus({ batchId }) {
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        method: "POST",
+        endpoint: FINBRICKS_ENDPOINTS.BATCH_STATUS,
+        body: {
+          merchantId: this.finbricks.MERCHANT_ID,
+          merchantBatchId: batchId
+        }
+      })
+    );
+    if (error || !response) {
+      throw createInternalError(error, {
+        message: "Finbricks: failed to fetch batch status"
+      });
+    }
+    return mapFinbricksBatchStatus(response.batchResultCode);
+  }
+}
+
+const isDeposit = (payment, creditorIban) => {
+  return payment.creditorIban === creditorIban;
+};
+const getPaymentDirection = (payment, iban) => {
+  if (isDeposit(payment, iban)) return "INCOMING";
+  return "OUTGOING";
+};
+
 class ErsteConnector extends IBankConnector {
   constructor(config) {
     super();
@@ -76,6 +537,9 @@ class ErsteConnector extends IBankConnector {
     this.PAYMENTS_URI = config.PAYMENTS_URI;
     this.ACCOUNTS_URI = config.ACCOUNTS_URI;
   }
+  connectUserAccount() {
+    throw new Error("Method not implemented.");
+  }
   static {
     this.FETCH_INTERVAL = 60 * 60 * 5;
   }
@@ -120,6 +584,9 @@ class ErsteConnector extends IBankConnector {
     this.accessToken = json.access_token;
     return json.refresh_token || "";
   }
+  listAccounts() {
+    throw new Error("Method not implemented.");
+  }
   async preparePayment(payment) {
     if (!this.accessToken) {
       throw createInternalError(null, {
@@ -306,319 +773,11 @@ class ErsteConnector extends IBankConnector {
     });
     return payments;
   }
-}
-
-const mapFinbricksStatus = (status) => {
-  switch (status) {
-    case "BOOK":
-      return "COMPLETED";
-    case "PDNG":
-      return "PENDING";
-    case "CANCL":
-      return "FAILED";
-    case "RJCT":
-      return "FAILED";
-    case "SCHDL":
-      return "PENDING";
-    case "HOLD":
-      return "PENDING";
-    case "INFO":
-      return "PENDING";
-    default:
-      return "PENDING";
-  }
-};
-
-class FinbricksConnector extends IBankConnector {
-  constructor(PROVIDER, { BASE_URI, MERCHANT_ID, PRIVATE_KEY_PEM }) {
-    super();
-    this.connectorKey = "FINBRICKS";
-    this.apiDictionary = /* @__PURE__ */ new Map([
-      ["single-payment-domestic", "/transaction/platform/init"],
-      ["batch-payment-domestic", "/transaction/platform/batchPayment/init"],
-      ["get-accounts", "/account/list"],
-      ["get-account-transactions", "/account/transactions"],
-      ["authenticate-client", "/v2/auth/authenticate"],
-      ["expiration", "/auth/token"]
-    ]);
-    this.PROVIDER = PROVIDER;
-    this.BASE_URI = BASE_URI;
-    this.MERCHANT_ID = MERCHANT_ID;
-    this.PRIVATE_KEY_PEM = PRIVATE_KEY_PEM;
-  }
-  static {
-    this.FETCH_INTERVAL = 60 * 60 * 5;
-  }
-  async signFinbricksJws({ jwsData }) {
-    const privateKey = await importPKCS8(this.PRIVATE_KEY_PEM, "RS256");
-    const payload = JSON.stringify(jwsData);
-    const jws = await new SignJWT(JSON.parse(payload)).setProtectedHeader({
-      alg: "RS256",
-      kid: this.MERCHANT_ID,
-      typ: "JWT"
-    }).sign(privateKey);
-    return jws;
-  }
-  async authenticate({ token }) {
-    this.lastValidClientId = token;
-    return this.lastValidClientId;
-  }
-  async isClientIdExpired(clientId) {
-    const query = new URLSearchParams({
-      merchantId: this.MERCHANT_ID,
-      provider: this.PROVIDER,
-      clientId
-    });
-    const uri = this.apiDictionary.get("expiration");
-    const fullUri = `${uri}?${query.toString()}`;
-    const signature = await this.signFinbricksJws({
-      jwsData: {
-        body: "",
-        uri: fullUri
-      }
-    });
-    const [data, error] = await useResult(
-      fetch(`${this.BASE_URI}${fullUri}`, {
-        method: "POST",
-        headers: {
-          "JWS-Signature": signature,
-          "Content-Type": "application/json"
-        },
-        body: ""
-      })
-    );
-    if (error) {
-      const body = await data?.json();
-      throw createInternalError(error, {
-        message: body?.message || "Finbricks API error"
-      });
-    }
-    if (!data?.ok) {
-      const body = await data.json();
-      throw createInternalError(null, {
-        message: body.message || "Finbricks API error",
-        code: "FINBRICKS_API_ERROR",
-        status: data?.status || 500
-      });
-    }
-    const tokens = await data.json();
-    return !!tokens.find((token) => token.clientId === clientId);
-  }
-  async preparePayment(payment) {
-    const bankRefId = uuidv4();
-    return {
-      ...payment,
-      id: uuidv4(),
-      bankRefId,
-      direction: "OUTGOING",
-      paymentType: "DOMESTIC",
-      status: "PREPARED",
-      initiatedAt: /* @__PURE__ */ new Date()
-    };
-  }
-  async initiateBatchFromPayments({
-    payments
-  }) {
-    const uri = this.apiDictionary.get("batch-payment-domestic");
-    const batchId = uuidv4();
-    const batchBody = {
-      batchPaymentIdentification: {
-        merchantId: this.MERCHANT_ID,
-        debtorAccountIban: payments[0].debtorIban,
-        clientId: this.lastValidClientId,
-        callbackUrl: "https://example.com/callback",
-        merchantBatchId: batchId
-      },
-      payments: payments.map((payment) => ({
-        merchantTransactionId: payment.bankRefId,
-        creditorAccountIban: payment.creditorIban,
-        amount: payment.amount
-      }))
-    };
-    const payload = JSON.stringify(batchBody);
-    const jwsData = {
-      uri,
-      body: payload
-    };
-    const signature = await this.signFinbricksJws({
-      jwsData
-    });
-    const [data, error] = await useResult(
-      fetch(`${this.BASE_URI}${uri}`, {
-        method: "POST",
-        headers: {
-          "JWS-Signature": signature,
-          "Content-Type": "application/json"
-        },
-        body: payload
-      })
-    );
-    const body = await data?.json();
-    if (error) {
-      throw createInternalError(error, {
-        message: body?.message || "Finbricks API error"
-      });
-    }
-    if (!data?.ok) {
-      console.log("FINBRICKSBODY", body);
-      throw createInternalError(null, {
-        message: body?.message || "Finbricks API error",
-        code: "FINBRICKS_API_ERROR",
-        status: data?.status || 500
-      });
-    }
-    const { redirectUrl } = body;
-    return {
-      id: batchId,
-      authorizationUrls: [redirectUrl],
-      payments: payments.map((payment) => ({
-        ...payment,
-        status: "INITIALIZED"
-      }))
-    };
-  }
-  async initiateSinglePayment(payment) {
-    const uri = this.apiDictionary.get("single-payment-domestic");
-    const paymentBody = {
-      merchantId: this.MERCHANT_ID,
-      merchantTransactionId: payment.bankRefId,
-      totalPrice: payment.amount,
-      creditorAccountIban: payment.creditorIban,
-      debtorAccountIban: payment.debtorIban,
-      creditorName: payment.creditorHolderName,
-      description: payment.message || "",
-      variableSymbol: payment.vs || "",
-      callbackUrl: "example.com",
-      paymentProvider: this.PROVIDER
-    };
-    const signature = await this.signFinbricksJws({
-      jwsData: {
-        body: JSON.stringify(paymentBody),
-        uri
-      }
-    });
-    const [data, error] = await useResult(
-      fetch(`${this.BASE_URI}${uri}`, {
-        method: "POST",
-        headers: {
-          "JWS-Signature": signature,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(paymentBody)
-      })
-    );
-    const body = await data?.json();
-    if (error) {
-      throw createInternalError(error, {
-        message: body?.message || "Finbricks API error"
-      });
-    }
-    if (!data?.ok) {
-      console.log("FINBRICKSBODY", body);
-      throw createInternalError(null, {
-        message: body?.message || "Finbricks API error",
-        code: "FINBRICKS_API_ERROR",
-        status: data?.status || 500
-      });
-    }
-    const redirectUrl = (await data.json()).redirectUrl;
-    return {
-      authorizationUrl: redirectUrl,
-      payment: { ...payment, status: "INITIALIZED" }
-    };
+  getPaymentStatus(_) {
+    throw new Error("Method not implemented.");
   }
-  async getAllAccountPayments({
-    account,
-    lastSync
-  }) {
-    const uri = this.apiDictionary.get("get-account-transactions");
-    const dateFormat = "yyyy-MM-dd";
-    let cursor = null;
-    let allPayments = [];
-    const dateFrom = format(lastSync.lastSyncedAt, dateFormat);
-    const dateTo = format(/* @__PURE__ */ new Date(), dateFormat);
-    do {
-      const query = new URLSearchParams({
-        merchantId: this.MERCHANT_ID,
-        clientId: this.lastValidClientId,
-        paymentProvider: this.PROVIDER,
-        bankAccountId: account.identification.number,
-        dateFrom,
-        dateTo,
-        currency: account.currency,
-        size: "20"
-      });
-      console.log("query", query);
-      if (cursor) query.set("cursor", cursor);
-      const fullUri = `${uri}?${query.toString()}`;
-      const jwsData = {
-        uri: fullUri,
-        body: ""
-      };
-      const signature = await this.signFinbricksJws({ jwsData });
-      console.log("signature ready", signature);
-      const [data, error] = await useResult(
-        fetch(`${this.BASE_URI}${fullUri}`, {
-          method: "GET",
-          headers: {
-            "JWS-Signature": signature,
-            "Content-Type": "application/json"
-          }
-        })
-      );
-      if (error) {
-        const body = await data?.json();
-        throw createInternalError(error, {
-          message: body?.message || "Finbricks API error"
-        });
-      }
-      if (!data?.ok) {
-        const body = await data.json();
-        throw createInternalError(null, {
-          message: body.message || "Finbricks API error",
-          code: "FINBRICKS_API_ERROR",
-          status: data?.status || 500
-        });
-      }
-      const { transactions, links } = await data.json();
-      cursor = links?.[0]?.value || null;
-      allPayments = [
-        ...allPayments,
-        ...transactions.map((tx) => {
-          const isIncoming = tx.creditDebitIndicator === "CRDT";
-          const relatedParties = tx.entryDetails?.transactionDetails?.relatedParties;
-          const paymentInsert = {
-            id: uuidv4(),
-            bankRefId: tx.entryReference || tx.fbxReference,
-            amount: tx.amount?.value || 0,
-            currency: tx.amount?.currency || "CZK",
-            debtorHolderName: isIncoming ? relatedParties?.debtor?.name || "Unknown" : "Unknown",
-            debtorIban: isIncoming ? relatedParties?.debtorAccount?.identification?.iban || account.identification.iban : account.identification.iban,
-            debtorAccountNumberWithBankCode: isIncoming ? relatedParties?.debtorAccount?.identification?.other?.identification || `${account.identification.number}/${account.identification.bankCode}` : `${account.identification.number}/${account.identification.bankCode}`,
-            creditorHolderName: isIncoming ? "Unknown" : relatedParties?.creditor?.name || "Unknown",
-            creditorIban: isIncoming ? account.identification.iban : relatedParties?.creditorAccount?.identification?.iban || account.identification.iban,
-            creditorAccountNumberWithBankCode: isIncoming ? `${account.identification.number}/${account.identification.bankCode}` : relatedParties?.creditorAccount?.identification?.other?.identification || `${account.identification.number}/${account.identification.bankCode}`,
-            paymentType: "DOMESTIC",
-            direction: isIncoming ? "INCOMING" : "OUTGOING",
-            message: tx.entryDetails?.transactionDetails?.remittanceInformation?.unstructured || tx.entryDetails?.transactionDetails?.additionalRemittanceInformation || null,
-            ...mapReferencesToPayment(
-              tx.entryDetails?.transactionDetails?.remittanceInformation?.structured?.creditorReferenceInformation?.reference || tx.entryDetails?.transactionDetails?.references?.endToEndIdentification
-            ),
-            processedAt: new Date(tx.bookingDate.date),
-            status: "COMPLETED"
-          };
-          return {
-            ...paymentInsert,
-            direction: getPaymentDirection(
-              paymentInsert,
-              account.identification.iban
-            ),
-            status: mapFinbricksStatus(tx.status)
-          };
-        })
-      ];
-    } while (cursor != null);
-    return allPayments;
+  getBatchStatus(_) {
+    throw new Error("Method not implemented.");
   }
 }
 
@@ -633,6 +792,15 @@ class MockConnector extends IBankConnector {
   async authenticate() {
     return "";
   }
+  async listAccounts() {
+    return [];
+  }
+  async connectUserAccount() {
+    return {
+      clientId: uuidv4(),
+      redirectUrl: ""
+    };
+  }
   async preparePayment(payment) {
     const bankRefId = uuidv4();
     return {
@@ -680,6 +848,12 @@ class MockConnector extends IBankConnector {
       status: "COMPLETED"
     }));
   }
+  getPaymentStatus(_) {
+    throw new Error("Method not implemented.");
+  }
+  getBatchStatus(_) {
+    throw new Error("Method not implemented.");
+  }
 }
 
 class MockCobsConnector extends FinbricksConnector {
@@ -700,6 +874,8 @@ const paymentInsertTypeZod = z.object({
   bankPaymentInitiatedAt: z.coerce.date(),
   bankPaymentProcessedAt: z.coerce.date(),
   bankingVs: z.string().max(10),
+  bankingSs: z.string().max(10),
+  bankingKs: z.string().max(10),
   message: z.string(),
   creditorIban: z.string().max(34),
   creditorHolderName: z.string(),
@@ -707,4 +883,4 @@ const paymentInsertTypeZod = z.object({
   debtorHolderName: z.string().nullable()
 });
 
-export { BATCH_STATUSES as B, COUNTRY_CODES as C, ErsteConnector as E, FinbricksConnector as F, IBankConnector as I, MockConnector as M, PAYMENT_TYPES as P, MockCobsConnector as a, PAYMENT_STATUSES as b, PAYMENT_DIRECTIONS as c, getPaymentDirection as g, paymentInsertTypeZod as p, tables as t };
+export { BATCH_STATUSES as B, COUNTRY_CODES as C, ErsteConnector as E, FinbricksConnector as F, IBankConnector as I, MockConnector as M, PAYMENT_TYPES as P, MockCobsConnector as a, FinbricksClient as b, FINBRICKS_ENDPOINTS as c, PAYMENT_STATUSES as d, PAYMENT_DIRECTIONS as e, getPaymentDirection as g, paymentInsertTypeZod as p, signFinbricksJws as s, tables as t, useFinbricksFetch as u };