From cbefcdc963cfde21ff986ba507cc9b558cd66d38 Mon Sep 17 00:00:00 2001 From: Claus-Peter Huebner Date: Fri, 28 Jul 2023 03:11:55 +0200 Subject: [PATCH] additional tests, but still work in progress --- backend/src/apis/DltConnectorClient.ts | 45 +- .../sendTransactionsToDltConnector.test.ts | 581 ++++++++++++++++++ .../util/sendTransactionsToDltConnector.ts | 46 +- 3 files changed, 637 insertions(+), 35 deletions(-) create mode 100644 backend/src/graphql/resolver/util/sendTransactionsToDltConnector.test.ts diff --git a/backend/src/apis/DltConnectorClient.ts b/backend/src/apis/DltConnectorClient.ts index 2f2e25858..e108dfa74 100644 --- a/backend/src/apis/DltConnectorClient.ts +++ b/backend/src/apis/DltConnectorClient.ts @@ -6,9 +6,9 @@ import { TransactionTypeId } from '@/graphql/enum/TransactionTypeId' import { LogError } from '@/server/LogError' import { backendLogger as logger } from '@/server/logger' -const mutation = gql` +const sendTransaction = gql` mutation ($input: TransactionInput!) { - transmitTransaction(data: $input) { + sendTransaction(data: $input) { dltTransactionIdHex } } @@ -35,7 +35,7 @@ function getTransactionTypeString(id: TransactionTypeId): string { export class DltConnectorClient { // eslint-disable-next-line no-use-before-define private static instance: DltConnectorClient - private client: GraphQLClient + client: GraphQLClient /** * The Singleton's constructor should always be private to prevent direct * construction calls with the `new` operator. @@ -59,7 +59,13 @@ export class DltConnectorClient { } if (!DltConnectorClient.instance.client) { try { - DltConnectorClient.instance.client = new GraphQLClient(CONFIG.DLT_CONNECTOR_URL) + DltConnectorClient.instance.client = new GraphQLClient(CONFIG.DLT_CONNECTOR_URL, { + method: 'GET', + jsonSerializer: { + parse: JSON.parse, + stringify: JSON.stringify, + }, + }) } catch (e) { logger.error("couldn't connect to dlt-connector: ", e) return @@ -72,22 +78,33 @@ export class DltConnectorClient { * transmit transaction via dlt-connector to iota * and update dltTransactionId of transaction in db with iota message id */ - public async transmitTransaction(transaction: DbTransaction): Promise { - const typeString = getTransactionTypeString(transaction.typeId) - const secondsSinceEpoch = Math.round(transaction.balanceDate.getTime() / 1000) - const amountString = transaction.amount.toString() - try { - const result: { transmitTransaction: { dltTransactionIdHex: string } } = - await this.client.request(mutation, { + public async transmitTransaction(transaction?: DbTransaction | null): Promise { + console.log('transmitTransaction tx=', transaction) + if (transaction) { + const typeString = getTransactionTypeString(transaction.typeId) + const secondsSinceEpoch = Math.round(transaction.balanceDate.getTime() / 1000) + const amountString = transaction.amount.toString() + console.log('typeString=', typeString) + console.log('secondsSinceEpoch=', secondsSinceEpoch) + console.log('amountString=', amountString) + try { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const { data } = await this.client.rawRequest(sendTransaction, { input: { type: typeString, amount: amountString, createdAt: secondsSinceEpoch, }, }) - return result.transmitTransaction.dltTransactionIdHex - } catch (e) { - throw new LogError('Error send sending transaction to dlt-connector: %o', e) + console.log('result data=', data) + // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access + return data.sendTransaction.dltTransactionIdHex + } catch (e) { + console.log('error return result ', e) + throw new LogError('Error send sending transaction to dlt-connector: ', e) + } + } else { + throw new LogError('parameter transaction not set...') } } } diff --git a/backend/src/graphql/resolver/util/sendTransactionsToDltConnector.test.ts b/backend/src/graphql/resolver/util/sendTransactionsToDltConnector.test.ts new file mode 100644 index 000000000..40d70e6dc --- /dev/null +++ b/backend/src/graphql/resolver/util/sendTransactionsToDltConnector.test.ts @@ -0,0 +1,581 @@ +/* eslint-disable @typescript-eslint/no-unsafe-member-access */ +/* eslint-disable @typescript-eslint/unbound-method */ +/* eslint-disable @typescript-eslint/no-unsafe-assignment */ +/* eslint-disable @typescript-eslint/no-unsafe-call */ +/* eslint-disable @typescript-eslint/no-explicit-any */ +/* eslint-disable @typescript-eslint/explicit-module-boundary-types */ + +import { Connection } from '@dbTools/typeorm' +import { DltTransaction } from '@entity/DltTransaction' +import { Transaction } from '@entity/Transaction' +import { ApolloServerTestClient } from 'apollo-server-testing' +import { Decimal } from 'decimal.js-light' +// import { GraphQLClient } from 'graphql-request' +// import { Response } from 'graphql-request/dist/types' +import { GraphQLClient } from 'graphql-request' +import { Response } from 'graphql-request/dist/types' + +import { testEnvironment, cleanDB } from '@test/helpers' +import { logger, i18n as localization } from '@test/testSetup' + +import { CONFIG } from '@/config' +import { TransactionTypeId } from '@/graphql/enum/TransactionTypeId' + +import { sendTransactionsToDltConnector } from './sendTransactionsToDltConnector' + +/* +// Mock the GraphQLClient +jest.mock('graphql-request', () => { + const originalModule = jest.requireActual('graphql-request') + + let testCursor = 0 + + return { + __esModule: true, + ...originalModule, + GraphQLClient: jest.fn().mockImplementation((url: string) => { + if (url === 'invalid') { + throw new Error('invalid url') + } + return { + // why not using mockResolvedValueOnce or mockReturnValueOnce? + // I have tried, but it didn't work and return every time the first value + request: jest.fn().mockImplementation(() => { + testCursor++ + if (testCursor === 4) { + return Promise.resolve( + // invalid, is 33 Bytes long as binary + { + transmitTransaction: { + dltTransactionIdHex: + '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc516212A', + }, + }, + ) + } else if (testCursor === 5) { + throw Error('Connection error') + } else { + return Promise.resolve( + // valid, is 32 Bytes long as binary + { + transmitTransaction: { + dltTransactionIdHex: + '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621', + }, + }, + ) + } + }), + } + }), + } +}) +let mutate: ApolloServerTestClient['mutate'], + query: ApolloServerTestClient['query'], + con: Connection +let testEnv: { + mutate: ApolloServerTestClient['mutate'] + query: ApolloServerTestClient['query'] + con: Connection +} +*/ + +async function createTxCREATION1(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(1000) + tx.balance = new Decimal(100) + tx.balanceDate = new Date('01.01.2023 00:00:00') + tx.memo = 'txCREATION1' + tx.typeId = TransactionTypeId.CREATION + tx.userGradidoID = 'txCREATION1.userGradidoID' + tx.userId = 1 + tx.userName = 'txCREATION 1' + return await Transaction.save(tx) +} + +async function createTxCREATION2(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(1000) + tx.balance = new Decimal(200) + tx.balanceDate = new Date('02.01.2023 00:00:00') + tx.memo = 'txCREATION2' + tx.typeId = TransactionTypeId.CREATION + tx.userGradidoID = 'txCREATION2.userGradidoID' + tx.userId = 2 + tx.userName = 'txCREATION 2' + return await Transaction.save(tx) +} + +async function createTxCREATION3(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(1000) + tx.balance = new Decimal(300) + tx.balanceDate = new Date('03.01.2023 00:00:00') + tx.memo = 'txCREATION3' + tx.typeId = TransactionTypeId.CREATION + tx.userGradidoID = 'txCREATION3.userGradidoID' + tx.userId = 3 + tx.userName = 'txCREATION 3' + return await Transaction.save(tx) +} + +async function createTxSend1ToReceive2(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(100) + tx.balance = new Decimal(1000) + tx.balanceDate = new Date('11.01.2023 00:00:00') + tx.memo = 'txSEND1 to txRECEIVE2' + tx.typeId = TransactionTypeId.SEND + tx.userGradidoID = 'txSEND1.userGradidoID' + tx.userId = 1 + tx.userName = 'txSEND 1' + tx.linkedUserGradidoID = 'txRECEIVE2.linkedUserGradidoID' + tx.linkedUserId = 2 + tx.linkedUserName = 'txRECEIVE 2' + return await Transaction.save(tx) +} + +async function createTxReceive2FromSend1(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(100) + tx.balance = new Decimal(1300) + tx.balanceDate = new Date('11.01.2023 00:00:00') + tx.memo = 'txSEND1 to txRECEIVE2' + tx.typeId = TransactionTypeId.RECEIVE + tx.userGradidoID = 'txRECEIVE2.linkedUserGradidoID' + tx.userId = 2 + tx.userName = 'txRECEIVE 2' + tx.linkedUserGradidoID = 'txSEND1.userGradidoID' + tx.linkedUserId = 1 + tx.linkedUserName = 'txSEND 1' + return await Transaction.save(tx) +} + +async function createTxSend2ToReceive3(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(200) + tx.balance = new Decimal(1100) + tx.balanceDate = new Date('23.01.2023 00:00:00') + tx.memo = 'txSEND2 to txRECEIVE3' + tx.typeId = TransactionTypeId.SEND + tx.userGradidoID = 'txSEND2.userGradidoID' + tx.userId = 2 + tx.userName = 'txSEND 2' + tx.linkedUserGradidoID = 'txRECEIVE3.linkedUserGradidoID' + tx.linkedUserId = 3 + tx.linkedUserName = 'txRECEIVE 3' + return await Transaction.save(tx) +} + +async function createTxReceive3FromSend2(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(200) + tx.balance = new Decimal(1500) + tx.balanceDate = new Date('23.01.2023 00:00:00') + tx.memo = 'txSEND2 to txRECEIVE3' + tx.typeId = TransactionTypeId.RECEIVE + tx.userGradidoID = 'txRECEIVE3.linkedUserGradidoID' + tx.userId = 3 + tx.userName = 'txRECEIVE 3' + tx.linkedUserGradidoID = 'txSEND2.userGradidoID' + tx.linkedUserId = 2 + tx.linkedUserName = 'txSEND 2' + return await Transaction.save(tx) +} + +async function createTxSend3ToReceive1(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(300) + tx.balance = new Decimal(1200) + tx.balanceDate = new Date('31.01.2023 00:00:00') + tx.memo = 'txSEND3 to txRECEIVE1' + tx.typeId = TransactionTypeId.SEND + tx.userGradidoID = 'txSEND3.userGradidoID' + tx.userId = 3 + tx.userName = 'txSEND 3' + tx.linkedUserGradidoID = 'txRECEIVE1.linkedUserGradidoID' + tx.linkedUserId = 1 + tx.linkedUserName = 'txRECEIVE 1' + return await Transaction.save(tx) +} + +async function createTxReceive1FromSend3(): Promise { + const tx = Transaction.create() + tx.amount = new Decimal(300) + tx.balance = new Decimal(1300) + tx.balanceDate = new Date('31.01.2023 00:00:00') + tx.memo = 'txSEND3 to txRECEIVE1' + tx.typeId = TransactionTypeId.RECEIVE + tx.userGradidoID = 'txRECEIVE1.linkedUserGradidoID' + tx.userId = 1 + tx.userName = 'txRECEIVE 1' + tx.linkedUserGradidoID = 'txSEND3.userGradidoID' + tx.linkedUserId = 3 + tx.linkedUserName = 'txSEND 3' + return await Transaction.save(tx) +} + +let con: Connection +let testEnv: { + mutate: ApolloServerTestClient['mutate'] + query: ApolloServerTestClient['query'] + con: Connection +} + +beforeAll(async () => { + testEnv = await testEnvironment(logger, localization) + con = testEnv.con + await cleanDB() +}) + +afterAll(async () => { + await cleanDB() + await con.close() +}) + +describe('create and send Transactions to DltConnector', () => { + let txCREATION1: Transaction + let txCREATION2: Transaction + let txCREATION3: Transaction + let txSEND1to2: Transaction + let txRECEIVE2From1: Transaction + let txSEND2To3: Transaction + let txRECEIVE3From2: Transaction + let txSEND3To1: Transaction + let txRECEIVE1From3: Transaction + + beforeEach(async () => { + jest.clearAllMocks() + + txCREATION1 = await createTxCREATION1() + txCREATION2 = await createTxCREATION2() + txCREATION3 = await createTxCREATION3() + }) + + describe('with 3 creations but inactive dlt-connector', () => { + beforeEach(async () => { + jest.clearAllMocks() + CONFIG.DLT_CONNECTOR = false + await sendTransactionsToDltConnector() + }) + + it('found 3 dlt-transactions', async () => { + expect(logger.info).toBeCalledWith('sendTransactionsToDltConnector...') + + // Find the previous created transactions of sendCoin mutation + const transactions = await Transaction.find({ + // where: { memo: 'unrepeatable memo' }, + order: { balanceDate: 'ASC', id: 'ASC' }, + }) + + const dltTransactions = await DltTransaction.find({ + // where: { transactionId: In([transaction[0].id, transaction[1].id]) }, + // relations: ['transaction'], + order: { createdAt: 'ASC', id: 'ASC' }, + }) + + expect(dltTransactions).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + id: expect.any(Number), + transactionId: transactions[0].id, + messageId: null, + verified: false, + createdAt: expect.any(Date), + verifiedAt: null, + }), + expect.objectContaining({ + id: expect.any(Number), + transactionId: transactions[1].id, + messageId: null, + verified: false, + createdAt: expect.any(Date), + verifiedAt: null, + }), + expect.objectContaining({ + id: expect.any(Number), + transactionId: transactions[2].id, + messageId: null, + verified: false, + createdAt: expect.any(Date), + verifiedAt: null, + }), + ]), + ) + + expect(logger.info).nthCalledWith(3, 'sending to DltConnector currently not configured...') + }) + }) + + describe('with 3 creations and active dlt-connector', () => { + beforeEach(async () => { + jest.clearAllMocks() + CONFIG.DLT_CONNECTOR = true + + // eslint-disable-next-line @typescript-eslint/require-await + jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return { + data: { + sendTransaction: { + dltTransactionIdHex: + '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc516212', + }, + }, + } as Response + }) + + await sendTransactionsToDltConnector() + }) + + it('found 3 dlt-transactions', async () => { + expect(logger.info).toBeCalledWith('sendTransactionsToDltConnector...') + + // Find the previous created transactions of sendCoin mutation + const transactions = await Transaction.find({ + // where: { memo: 'unrepeatable memo' }, + order: { balanceDate: 'ASC', id: 'ASC' }, + }) + + const dltTransactions = await DltTransaction.find({ + // where: { transactionId: In([transaction[0].id, transaction[1].id]) }, + // relations: ['transaction'], + order: { createdAt: 'ASC', id: 'ASC' }, + }) + + expect(dltTransactions).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + id: expect.any(Number), + transactionId: transactions[0].id, + messageId: '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621', + verified: false, + createdAt: expect.any(Date), + verifiedAt: null, + }), + expect.objectContaining({ + id: expect.any(Number), + transactionId: transactions[1].id, + messageId: '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621', + verified: false, + createdAt: expect.any(Date), + verifiedAt: null, + }), + expect.objectContaining({ + id: expect.any(Number), + transactionId: transactions[2].id, + messageId: '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621', + verified: false, + createdAt: expect.any(Date), + verifiedAt: null, + }), + ]), + ) + }) + + /* + describe('with one Community of api 1_0 and not matching pubKey', () => { + beforeEach(async () => { + // eslint-disable-next-line @typescript-eslint/require-await + jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return { + data: { + getPublicKey: { + publicKey: 'somePubKey', + }, + }, + } as Response + }) + const variables1 = { + publicKey: Buffer.from('11111111111111111111111111111111'), + apiVersion: '1_0', + endPoint: 'http//localhost:5001/api/', + lastAnnouncedAt: new Date(), + } + await DbFederatedCommunity.createQueryBuilder() + .insert() + .into(DbFederatedCommunity) + .values(variables1) + .orUpdate({ + // eslint-disable-next-line camelcase + conflict_target: ['id', 'publicKey', 'apiVersion'], + overwrite: ['end_point', 'last_announced_at'], + }) + .execute() + + jest.clearAllMocks() + // await validateCommunities() + }) + + it('logs one community found', () => { + expect(logger.debug).toBeCalledWith(`Federation: found 1 dbCommunities`) + }) + it('logs requestGetPublicKey for community api 1_0 ', () => { + expect(logger.info).toBeCalledWith( + 'Federation: getPublicKey from endpoint', + 'http//localhost:5001/api/1_0/', + ) + }) + it('logs not matching publicKeys', () => { + expect(logger.warn).toBeCalledWith( + 'Federation: received not matching publicKey:', + 'somePubKey', + expect.stringMatching('11111111111111111111111111111111'), + ) + }) + }) + describe('with one Community of api 1_0 and matching pubKey', () => { + beforeEach(async () => { + // eslint-disable-next-line @typescript-eslint/require-await + jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return { + data: { + getPublicKey: { + publicKey: '11111111111111111111111111111111', + }, + }, + } as Response + }) + const variables1 = { + publicKey: Buffer.from('11111111111111111111111111111111'), + apiVersion: '1_0', + endPoint: 'http//localhost:5001/api/', + lastAnnouncedAt: new Date(), + } + await DbFederatedCommunity.createQueryBuilder() + .insert() + .into(DbFederatedCommunity) + .values(variables1) + .orUpdate({ + // eslint-disable-next-line camelcase + conflict_target: ['id', 'publicKey', 'apiVersion'], + overwrite: ['end_point', 'last_announced_at'], + }) + .execute() + await DbFederatedCommunity.update({}, { verifiedAt: null }) + jest.clearAllMocks() + // await validateCommunities() + }) + + it('logs one community found', () => { + expect(logger.debug).toBeCalledWith(`Federation: found 1 dbCommunities`) + }) + it('logs requestGetPublicKey for community api 1_0 ', () => { + expect(logger.info).toBeCalledWith( + 'Federation: getPublicKey from endpoint', + 'http//localhost:5001/api/1_0/', + ) + }) + it('logs community pubKey verified', () => { + expect(logger.info).toHaveBeenNthCalledWith( + 3, + 'Federation: verified community with', + 'http//localhost:5001/api/', + ) + }) + }) + describe('with two Communities of api 1_0 and 1_1', () => { + beforeEach(async () => { + jest.clearAllMocks() + // eslint-disable-next-line @typescript-eslint/require-await + jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return { + data: { + getPublicKey: { + publicKey: '11111111111111111111111111111111', + }, + }, + } as Response + }) + const variables2 = { + publicKey: Buffer.from('11111111111111111111111111111111'), + apiVersion: '1_1', + endPoint: 'http//localhost:5001/api/', + lastAnnouncedAt: new Date(), + } + await DbFederatedCommunity.createQueryBuilder() + .insert() + .into(DbFederatedCommunity) + .values(variables2) + .orUpdate({ + // eslint-disable-next-line camelcase + conflict_target: ['id', 'publicKey', 'apiVersion'], + overwrite: ['end_point', 'last_announced_at'], + }) + .execute() + + await DbFederatedCommunity.update({}, { verifiedAt: null }) + jest.clearAllMocks() + // await validateCommunities() + }) + it('logs two communities found', () => { + expect(logger.debug).toBeCalledWith(`Federation: found 2 dbCommunities`) + }) + it('logs requestGetPublicKey for community api 1_0 ', () => { + expect(logger.info).toBeCalledWith( + 'Federation: getPublicKey from endpoint', + 'http//localhost:5001/api/1_0/', + ) + }) + it('logs requestGetPublicKey for community api 1_1 ', () => { + expect(logger.info).toBeCalledWith( + 'Federation: getPublicKey from endpoint', + 'http//localhost:5001/api/1_1/', + ) + }) + }) + describe('with three Communities of api 1_0, 1_1 and 2_0', () => { + let dbCom: DbFederatedCommunity + beforeEach(async () => { + const variables3 = { + publicKey: Buffer.from('11111111111111111111111111111111'), + apiVersion: '2_0', + endPoint: 'http//localhost:5001/api/', + lastAnnouncedAt: new Date(), + } + await DbFederatedCommunity.createQueryBuilder() + .insert() + .into(DbFederatedCommunity) + .values(variables3) + .orUpdate({ + // eslint-disable-next-line camelcase + conflict_target: ['id', 'publicKey', 'apiVersion'], + overwrite: ['end_point', 'last_announced_at'], + }) + .execute() + dbCom = await DbFederatedCommunity.findOneOrFail({ + where: { publicKey: variables3.publicKey, apiVersion: variables3.apiVersion }, + }) + await DbFederatedCommunity.update({}, { verifiedAt: null }) + jest.clearAllMocks() + // await validateCommunities() + }) + it('logs three community found', () => { + expect(logger.debug).toBeCalledWith(`Federation: found 3 dbCommunities`) + }) + it('logs requestGetPublicKey for community api 1_0 ', () => { + expect(logger.info).toBeCalledWith( + 'Federation: getPublicKey from endpoint', + 'http//localhost:5001/api/1_0/', + ) + }) + it('logs requestGetPublicKey for community api 1_1 ', () => { + expect(logger.info).toBeCalledWith( + 'Federation: getPublicKey from endpoint', + 'http//localhost:5001/api/1_1/', + ) + }) + it('logs unsupported api for community with api 2_0 ', () => { + expect(logger.warn).toBeCalledWith( + 'Federation: dbCom with unsupported apiVersion', + dbCom.endPoint, + '2_0', + ) + }) + }) + */ + }) +}) diff --git a/backend/src/graphql/resolver/util/sendTransactionsToDltConnector.ts b/backend/src/graphql/resolver/util/sendTransactionsToDltConnector.ts index 64a0c5a7b..49a1acdc8 100644 --- a/backend/src/graphql/resolver/util/sendTransactionsToDltConnector.ts +++ b/backend/src/graphql/resolver/util/sendTransactionsToDltConnector.ts @@ -17,37 +17,41 @@ export async function sendTransactionsToDltConnector(): Promise { await createDltTransactions() const dltConnector = DltConnectorClient.getInstance() if (dltConnector) { + console.log('aktiv dltConnector...') + logger.debug('with sending to DltConnector...') const dltTransactions = await DltTransaction.find({ where: { messageId: IsNull() }, relations: ['transaction'], order: { createdAt: 'ASC', id: 'ASC' }, }) + console.log('dltTransactions=', dltTransactions) for (const dltTx of dltTransactions) { - logger.debug('sending dltTx=', dltTx) - if (dltTx.transaction && (dltTx.transaction ?? false)) { - try { - const messageId = await dltConnector.transmitTransaction(dltTx.transaction) - logger.debug('received messageId=', messageId) - const dltMessageId = Buffer.from(messageId, 'hex') - logger.debug('dltMessageId as Buffer=', dltMessageId) - if (dltMessageId.length !== 32) { - logger.error( - 'Error dlt message id is invalid: %s, should by 32 Bytes long in binary after converting from hex', - dltMessageId, - ) - return - } - dltTx.messageId = dltMessageId.toString() - await DltTransaction.save(dltTx) - logger.info('store messageId=%s in dltTx=%d', dltTx.messageId, dltTx.id) - } catch (e) { - logger.error( - `error while sending to dlt-connector or writing messageId of dltTx=${dltTx.id}`, - e, + console.log('sending dltTx=', dltTx) + try { + const messageId = await dltConnector.transmitTransaction(dltTx.transaction) + console.log('received messageId=', messageId) + const dltMessageId = Buffer.from(messageId, 'hex') + console.log('dltMessageId as Buffer=', dltMessageId) + if (dltMessageId.length !== 32) { + console.log( + 'Error dlt message id is invalid: %s, should by 32 Bytes long in binary after converting from hex', + dltMessageId, ) + return } + dltTx.messageId = dltMessageId.toString('hex') + await DltTransaction.save(dltTx) + logger.info('store messageId=%s in dltTx=%d', dltTx.messageId, dltTx.id) + } catch (e) { + console.log('error ', e) + logger.error( + `error while sending to dlt-connector or writing messageId of dltTx=${dltTx.id}`, + e, + ) } } + } else { + logger.info('sending to DltConnector currently not configured...') } } catch (e) { logger.error('error on sending transactions to dlt-connector.', e)