1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
|
/*
* This file is part of LibEuFin.
* Copyright (C) 2020 Taler Systems S.A.
*
* LibEuFin is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation; either version 3, or
* (at your option) any later version.
*
* LibEuFin is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General
* Public License for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with LibEuFin; see the file COPYING. If not, see
* <http://www.gnu.org/licenses/>
*/
package tech.libeufin.nexus
import org.jetbrains.exposed.dao.*
import org.jetbrains.exposed.dao.id.EntityID
import org.jetbrains.exposed.dao.id.LongIdTable
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.TransactionManager
import org.jetbrains.exposed.sql.transactions.transaction
import tech.libeufin.nexus.iso20022.EntryStatus
import tech.libeufin.util.EbicsInitState
import tech.libeufin.util.amount
import java.sql.Connection
/**
* This table holds the values that exchange gave to issue a payment,
* plus a reference to the prepared pain.001 version of. Note that
* whether a pain.001 document was sent or not to the bank is indicated
* in the PAIN-table.
*/
object TalerRequestedPaymentsTable : LongIdTable() {
val facade = reference("facade", FacadesTable)
val preparedPayment = reference("payment", PaymentInitiationsTable)
val requestUid = text("requestUid")
val amount = text("amount")
val exchangeBaseUrl = text("exchangeBaseUrl")
val wtid = text("wtid")
val creditAccount = text("creditAccount")
}
class TalerRequestedPaymentEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<TalerRequestedPaymentEntity>(TalerRequestedPaymentsTable)
var facade by FacadeEntity referencedOn TalerRequestedPaymentsTable.facade
var preparedPayment by PaymentInitiationEntity referencedOn TalerRequestedPaymentsTable.preparedPayment
var requestUid by TalerRequestedPaymentsTable.requestUid
var amount by TalerRequestedPaymentsTable.amount
var exchangeBaseUrl by TalerRequestedPaymentsTable.exchangeBaseUrl
var wtid by TalerRequestedPaymentsTable.wtid
var creditAccount by TalerRequestedPaymentsTable.creditAccount
}
object TalerInvalidIncomingPaymentsTable : LongIdTable() {
val payment = reference("payment", NexusBankTransactionsTable)
val timestampMs = long("timestampMs")
val refunded = bool("refunded").default(false)
}
class TalerInvalidIncomingPaymentEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<TalerInvalidIncomingPaymentEntity>(TalerInvalidIncomingPaymentsTable)
var payment by NexusBankTransactionEntity referencedOn TalerInvalidIncomingPaymentsTable.payment
var timestampMs by TalerInvalidIncomingPaymentsTable.timestampMs
// FIXME: This should probably not be called refunded, and
// we should have a foreign key to the payment that sends the
// money back.
var refunded by TalerInvalidIncomingPaymentsTable.refunded
}
object AnastasisIncomingPaymentsTable: LongIdTable() {
val payment = reference("payment", NexusBankTransactionsTable)
val subject = text("subject")
val timestampMs = long("timestampMs")
val debtorPaytoUri = text("incomingPaytoUri")
}
class AnastasisIncomingPaymentEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<AnastasisIncomingPaymentEntity>(AnastasisIncomingPaymentsTable)
var payment by NexusBankTransactionEntity referencedOn AnastasisIncomingPaymentsTable.payment
var subject by AnastasisIncomingPaymentsTable.subject
var timestampMs by AnastasisIncomingPaymentsTable.timestampMs
var debtorPaytoUri by AnastasisIncomingPaymentsTable.debtorPaytoUri
}
/**
* This is the table of the incoming payments. Entries are merely "pointers" to the
* entries from the raw payments table.
*/
object TalerIncomingPaymentsTable : LongIdTable() {
val payment = reference("payment", NexusBankTransactionsTable)
val reservePublicKey = text("reservePublicKey")
val timestampMs = long("timestampMs")
val debtorPaytoUri = text("incomingPaytoUri")
}
class TalerIncomingPaymentEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<TalerIncomingPaymentEntity>(TalerIncomingPaymentsTable)
var payment by NexusBankTransactionEntity referencedOn TalerIncomingPaymentsTable.payment
var reservePublicKey by TalerIncomingPaymentsTable.reservePublicKey
var timestampMs by TalerIncomingPaymentsTable.timestampMs
var debtorPaytoUri by TalerIncomingPaymentsTable.debtorPaytoUri
}
/**
* This table logs all the balances as returned by the bank for all the bank accounts.
*/
object NexusBankBalancesTable : LongIdTable() {
/**
* Balance mentioned in the bank message referenced below. NOTE: this is the
* CLOSING balance (a.k.a. CLBD), namely the one obtained by adding the transactions
* reported in the bank message to the _previous_ CLBD.
*/
val balance = text("balance") // $currency:x.y
val creditDebitIndicator = text("creditDebitIndicator") // CRDT or DBIT.
val bankAccount = reference("bankAccount", NexusBankAccountsTable)
val date = text("date") // in the YYYY-MM-DD format
}
class NexusBankBalanceEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusBankBalanceEntity>(NexusBankBalancesTable)
var balance by NexusBankBalancesTable.balance
var creditDebitIndicator by NexusBankBalancesTable.creditDebitIndicator
var bankAccount by NexusBankAccountEntity referencedOn NexusBankBalancesTable.bankAccount
var date by NexusBankBalancesTable.date
}
/**
* Table that stores all messages we receive from the bank.
*/
object NexusBankMessagesTable : LongIdTable() {
val bankConnection = reference("bankConnection", NexusBankConnectionsTable)
val messageId = text("messageId")
val code = text("code")
val message = blob("message")
val errors = bool("errors").default(false) // true when the parser could not ingest one message.
}
class NexusBankMessageEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusBankMessageEntity>(NexusBankMessagesTable)
var bankConnection by NexusBankConnectionEntity referencedOn NexusBankMessagesTable.bankConnection
var messageId by NexusBankMessagesTable.messageId
var code by NexusBankMessagesTable.code
var message by NexusBankMessagesTable.message
var errors by NexusBankMessagesTable.errors
}
/**
* This table contains history "elements" as returned by the bank from a
* CAMT message.
*/
object NexusBankTransactionsTable : LongIdTable() {
/**
* Identifier for the transaction that is unique among all transactions of the account.
* The scheme for this identifier is the accounts transaction identification scheme.
*
* Note that this is *not* a unique ID per account, as the same underlying
* transaction can show up multiple times with a different status.
*/
val accountTransactionId = text("accountTransactionId")
val bankAccount = reference("bankAccount", NexusBankAccountsTable)
val creditDebitIndicator = text("creditDebitIndicator")
val currency = text("currency")
val amount = text("amount")
val status = enumerationByName("status", 16, EntryStatus::class)
// Another, later transaction that updates the status of the current transaction.
val updatedBy = optReference("updatedBy", NexusBankTransactionsTable)
val transactionJson = text("transactionJson")
}
class NexusBankTransactionEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusBankTransactionEntity>(NexusBankTransactionsTable)
var currency by NexusBankTransactionsTable.currency
var amount by NexusBankTransactionsTable.amount
var status by NexusBankTransactionsTable.status
var creditDebitIndicator by NexusBankTransactionsTable.creditDebitIndicator
var bankAccount by NexusBankAccountEntity referencedOn NexusBankTransactionsTable.bankAccount
var transactionJson by NexusBankTransactionsTable.transactionJson
var accountTransactionId by NexusBankTransactionsTable.accountTransactionId
val updatedBy by NexusBankTransactionEntity optionalReferencedOn NexusBankTransactionsTable.updatedBy
}
/**
* Represents a prepared payment.
*/
object PaymentInitiationsTable : LongIdTable() {
/**
* Bank account that wants to initiate the payment.
*/
val bankAccount = reference("bankAccount", NexusBankAccountsTable)
val preparationDate = long("preparationDate")
val submissionDate = long("submissionDate").nullable()
val sum = text("sum") // the amount to transfer.
val currency = text("currency")
val endToEndId = text("endToEndId")
val paymentInformationId = text("paymentInformationId")
val instructionId = text("instructionId")
val subject = text("subject")
val creditorIban = text("creditorIban")
val creditorBic = text("creditorBic").nullable()
val creditorName = text("creditorName")
val submitted = bool("submitted").default(false)
var invalid = bool("invalid").nullable()
val messageId = text("messageId")
/**
* Points at the raw transaction witnessing that this
* initiated payment was successfully performed.
*/
val confirmationTransaction = reference("rawConfirmation", NexusBankTransactionsTable).nullable()
}
class PaymentInitiationEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<PaymentInitiationEntity>(PaymentInitiationsTable)
var bankAccount by NexusBankAccountEntity referencedOn PaymentInitiationsTable.bankAccount
var preparationDate by PaymentInitiationsTable.preparationDate
var submissionDate by PaymentInitiationsTable.submissionDate
var sum by PaymentInitiationsTable.sum
var currency by PaymentInitiationsTable.currency
var endToEndId by PaymentInitiationsTable.endToEndId
var subject by PaymentInitiationsTable.subject
var creditorIban by PaymentInitiationsTable.creditorIban
var creditorBic by PaymentInitiationsTable.creditorBic
var creditorName by PaymentInitiationsTable.creditorName
var submitted by PaymentInitiationsTable.submitted
var invalid by PaymentInitiationsTable.invalid
var paymentInformationId by PaymentInitiationsTable.paymentInformationId
var instructionId by PaymentInitiationsTable.instructionId
var messageId by PaymentInitiationsTable.messageId
var confirmationTransaction by NexusBankTransactionEntity optionalReferencedOn PaymentInitiationsTable.confirmationTransaction
}
/**
* This table contains the bank accounts that are offered by the bank.
* The bank account label (as assigned by the bank) is the primary key.
*/
object OfferedBankAccountsTable : LongIdTable() {
val offeredAccountId = text("offeredAccountId")
val bankConnection = reference("bankConnection", NexusBankConnectionsTable)
val iban = text("iban")
val bankCode = text("bankCode")
val accountHolder = text("holderName")
// column below gets defined only WHEN the user imports the bank account.
val imported = reference("imported", NexusBankAccountsTable).nullable()
init {
uniqueIndex(offeredAccountId, bankConnection)
}
}
class OfferedBankAccountEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<OfferedBankAccountEntity>(OfferedBankAccountsTable)
var offeredAccountId by OfferedBankAccountsTable.offeredAccountId
var bankConnection by NexusBankConnectionEntity referencedOn OfferedBankAccountsTable.bankConnection
var accountHolder by OfferedBankAccountsTable.accountHolder
var iban by OfferedBankAccountsTable.iban
var bankCode by OfferedBankAccountsTable.bankCode
var imported by NexusBankAccountEntity optionalReferencedOn OfferedBankAccountsTable.imported
}
/**
* This table holds triples of <iban, bic, holder name>.
* FIXME(dold): Allow other account and bank identifications than IBAN and BIC
*/
object NexusBankAccountsTable : LongIdTable() {
val bankAccountName = text("bankAccountId").uniqueIndex()
val accountHolder = text("accountHolder")
val iban = text("iban")
val bankCode = text("bankCode")
val defaultBankConnection = reference("defaultBankConnection", NexusBankConnectionsTable).nullable()
val lastStatementCreationTimestamp = long("lastStatementCreationTimestamp").nullable()
val lastReportCreationTimestamp = long("lastReportCreationTimestamp").nullable()
val lastNotificationCreationTimestamp = long("lastNotificationCreationTimestamp").nullable()
// Highest bank message ID that this bank account is aware of.
val highestSeenBankMessageSerialId = long("highestSeenBankMessageSerialId")
val pain001Counter = long("pain001counter").default(1)
}
class NexusBankAccountEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusBankAccountEntity>(NexusBankAccountsTable) {
fun findByName(name: String): NexusBankAccountEntity? {
return find { NexusBankAccountsTable.bankAccountName eq name }.firstOrNull()
}
}
var bankAccountName by NexusBankAccountsTable.bankAccountName
var accountHolder by NexusBankAccountsTable.accountHolder
var iban by NexusBankAccountsTable.iban
var bankCode by NexusBankAccountsTable.bankCode
var defaultBankConnection by NexusBankConnectionEntity optionalReferencedOn NexusBankAccountsTable.defaultBankConnection
var highestSeenBankMessageSerialId by NexusBankAccountsTable.highestSeenBankMessageSerialId
var pain001Counter by NexusBankAccountsTable.pain001Counter
var lastStatementCreationTimestamp by NexusBankAccountsTable.lastStatementCreationTimestamp
var lastReportCreationTimestamp by NexusBankAccountsTable.lastReportCreationTimestamp
var lastNotificationCreationTimestamp by NexusBankAccountsTable.lastNotificationCreationTimestamp
}
object NexusEbicsSubscribersTable : LongIdTable() {
val ebicsURL = text("ebicsURL")
val hostID = text("hostID")
val partnerID = text("partnerID")
val userID = text("userID")
val systemID = text("systemID").nullable()
val signaturePrivateKey = blob("signaturePrivateKey")
val encryptionPrivateKey = blob("encryptionPrivateKey")
val authenticationPrivateKey = blob("authenticationPrivateKey")
val bankEncryptionPublicKey = blob("bankEncryptionPublicKey").nullable()
val bankAuthenticationPublicKey = blob("bankAuthenticationPublicKey").nullable()
val nexusBankConnection = reference("nexusBankConnection", NexusBankConnectionsTable)
val ebicsIniState = enumerationByName("ebicsIniState", 16, EbicsInitState::class)
val ebicsHiaState = enumerationByName("ebicsHiaState", 16, EbicsInitState::class)
}
class EbicsSubscriberEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<EbicsSubscriberEntity>(NexusEbicsSubscribersTable)
var ebicsURL by NexusEbicsSubscribersTable.ebicsURL
var hostID by NexusEbicsSubscribersTable.hostID
var partnerID by NexusEbicsSubscribersTable.partnerID
var userID by NexusEbicsSubscribersTable.userID
var systemID by NexusEbicsSubscribersTable.systemID
var signaturePrivateKey by NexusEbicsSubscribersTable.signaturePrivateKey
var encryptionPrivateKey by NexusEbicsSubscribersTable.encryptionPrivateKey
var authenticationPrivateKey by NexusEbicsSubscribersTable.authenticationPrivateKey
var bankEncryptionPublicKey by NexusEbicsSubscribersTable.bankEncryptionPublicKey
var bankAuthenticationPublicKey by NexusEbicsSubscribersTable.bankAuthenticationPublicKey
var nexusBankConnection by NexusBankConnectionEntity referencedOn NexusEbicsSubscribersTable.nexusBankConnection
var ebicsIniState by NexusEbicsSubscribersTable.ebicsIniState
var ebicsHiaState by NexusEbicsSubscribersTable.ebicsHiaState
}
object NexusUsersTable : LongIdTable() {
val username = text("username")
val passwordHash = text("password")
val superuser = bool("superuser")
}
class NexusUserEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusUserEntity>(NexusUsersTable)
var username by NexusUsersTable.username
var passwordHash by NexusUsersTable.passwordHash
var superuser by NexusUsersTable.superuser
}
object NexusBankConnectionsTable : LongIdTable() {
val connectionId = text("connectionId")
val type = text("type")
val owner = reference("user", NexusUsersTable)
}
class NexusBankConnectionEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusBankConnectionEntity>(NexusBankConnectionsTable) {
fun findByName(name: String): NexusBankConnectionEntity? {
return find { NexusBankConnectionsTable.connectionId eq name }.firstOrNull()
}
}
var connectionId by NexusBankConnectionsTable.connectionId
var type by NexusBankConnectionsTable.type
var owner by NexusUserEntity referencedOn NexusBankConnectionsTable.owner
}
object FacadesTable : LongIdTable() {
val facadeName = text("facadeName")
val type = text("type")
val creator = reference("creator", NexusUsersTable)
init { uniqueIndex(facadeName) }
}
class FacadeEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<FacadeEntity>(FacadesTable) {
fun findByName(name: String): FacadeEntity? {
return find { FacadesTable.facadeName eq name}.firstOrNull()
}
}
var facadeName by FacadesTable.facadeName
var type by FacadesTable.type
var creator by NexusUserEntity referencedOn FacadesTable.creator
}
object FacadeStateTable : LongIdTable() {
val bankAccount = text("bankAccount")
val bankConnection = text("bankConnection")
val currency = text("currency")
// "statement", "report", "notification"
val reserveTransferLevel = text("reserveTransferLevel")
val facade = reference("facade", FacadesTable)
/**
* Highest ID seen in the raw transactions table.
*/
val highestSeenMsgSerialId = long("highestSeenMessageSerialId").default(0)
}
class FacadeStateEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<FacadeStateEntity>(FacadeStateTable)
var bankAccount by FacadeStateTable.bankAccount
var bankConnection by FacadeStateTable.bankConnection
var currency by FacadeStateTable.currency
/**
* "statement", "report", "notification"
*/
var reserveTransferLevel by FacadeStateTable.reserveTransferLevel
var facade by FacadeEntity referencedOn FacadeStateTable.facade
var highestSeenMessageSerialId by FacadeStateTable.highestSeenMsgSerialId
}
object NexusScheduledTasksTable : LongIdTable() {
val resourceType = text("resourceType")
val resourceId = text("resourceId")
val taskName = text("taskName")
val taskType = text("taskType")
val taskCronspec = text("taskCronspec")
val taskParams = text("taskParams")
val nextScheduledExecutionSec = long("nextScheduledExecutionSec").nullable()
val prevScheduledExecutionSec = long("lastScheduledExecutionSec").nullable()
}
class NexusScheduledTaskEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusScheduledTaskEntity>(NexusScheduledTasksTable)
var resourceType by NexusScheduledTasksTable.resourceType
var resourceId by NexusScheduledTasksTable.resourceId
var taskName by NexusScheduledTasksTable.taskName
var taskType by NexusScheduledTasksTable.taskType
var taskCronspec by NexusScheduledTasksTable.taskCronspec
var taskParams by NexusScheduledTasksTable.taskParams
var nextScheduledExecutionSec by NexusScheduledTasksTable.nextScheduledExecutionSec
var prevScheduledExecutionSec by NexusScheduledTasksTable.prevScheduledExecutionSec
}
/**
* Generic permissions table that determines access of a subject
* identified by (subjectType, subjectName) to a resource (resourceType, resourceId).
*
* Subjects are typically of type "user", but this may change in the future.
*/
object NexusPermissionsTable : LongIdTable() {
val resourceType = text("resourceType")
val resourceId = text("resourceId")
val subjectType = text("subjectType")
val subjectId = text("subjectName")
val permissionName = text("permissionName")
init {
uniqueIndex(resourceType, resourceId, subjectType, subjectId, permissionName)
}
}
class NexusPermissionEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<NexusPermissionEntity>(NexusPermissionsTable)
var resourceType by NexusPermissionsTable.resourceType
var resourceId by NexusPermissionsTable.resourceId
var subjectType by NexusPermissionsTable.subjectType
var subjectId by NexusPermissionsTable.subjectId
var permissionName by NexusPermissionsTable.permissionName
}
fun dbDropTables(dbConnectionString: String) {
Database.connect(dbConnectionString)
transaction {
SchemaUtils.drop(
NexusUsersTable,
PaymentInitiationsTable,
NexusEbicsSubscribersTable,
NexusBankAccountsTable,
NexusBankTransactionsTable,
TalerIncomingPaymentsTable,
TalerRequestedPaymentsTable,
TalerInvalidIncomingPaymentsTable,
NexusBankConnectionsTable,
NexusBankMessagesTable,
NexusBankBalancesTable,
FacadesTable,
FacadeStateTable,
NexusScheduledTasksTable,
OfferedBankAccountsTable,
NexusPermissionsTable,
AnastasisIncomingPaymentsTable
)
}
}
fun dbCreateTables(dbConnectionString: String) {
Database.connect(dbConnectionString)
TransactionManager.manager.defaultIsolationLevel = Connection.TRANSACTION_SERIALIZABLE
transaction {
SchemaUtils.create(
NexusScheduledTasksTable,
NexusUsersTable,
PaymentInitiationsTable,
NexusEbicsSubscribersTable,
NexusBankAccountsTable,
NexusBankBalancesTable,
NexusBankTransactionsTable,
AnastasisIncomingPaymentsTable,
TalerIncomingPaymentsTable,
TalerRequestedPaymentsTable,
FacadeStateTable,
TalerInvalidIncomingPaymentsTable,
NexusBankConnectionsTable,
NexusBankMessagesTable,
FacadesTable,
OfferedBankAccountsTable,
NexusPermissionsTable
)
}
}
|