@develit-services/ledger 0.0.1

package/dist/export/worker.mjs

@@ -0,0 +1,759 @@
+import { WorkerEntrypoint } from 'cloudflare:workers';
+import { first, develitWorker, uuidv4, useResult, createInternalError, cloudflareQueue, action, service } from '@develit-io/backend-sdk';
+import { e as createTransactionInputSchema, n as updateTransactionInputSchema, o as getTransactionByIdInputSchema, p as getTransactionsByReferenceIdInputSchema, q as getTransactionsInputSchema, d as createAccountInputSchema, u as updateAccountInputSchema, f as deleteAccountInputSchema, h as getAccountInputSchema, k as getAccountsByOwnerInputSchema, m as listAccountsInputSchema, j as getAccountIdentifierInputSchema, l as listAccountIdentifiersInputSchema, g as findAccountByIdentifierInputSchema, i as getAccountBalanceInputSchema, r as updateTransactionConfirmationSentAtInputSchema } from '../shared/ledger.ByUO4e44.mjs';
+import '@develit-io/general-codes';
+import { s as schema } from '../shared/ledger.Bl4HgQDw.mjs';
+import { eq, and, inArray, or, count, sql, gte, lte, asc, desc } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import 'zod';
+import 'drizzle-orm/sqlite-core';
+
+const tables = schema;
+
+const createAccountCommand = async (db, input) => {
+  const command = db.insert(tables.account).values(input).returning();
+  return { command };
+};
+
+const createAccountIdentifierCommand = async (db, input) => {
+  const command = db.insert(tables.accountIdentifier).values(input).returning();
+  return { command };
+};
+
+const deleteAccountCommand = async (db, id) => {
+  const accountIdentifierMappingCommand = db.delete(tables.accountIdentifierMapping).where(eq(tables.accountIdentifierMapping.accountId, id));
+  const accountCommand = db.delete(tables.account).where(eq(tables.account.id, id));
+  return { accountIdentifierMappingCommand, accountCommand };
+};
+
+const linkAccountIdentifierCommand = async (db, accountId, identifierId) => {
+  const command = db.insert(tables.accountIdentifierMapping).values({ accountId, identifierId }).returning();
+  return { command };
+};
+
+const updateAccountCommand = async (db, id, input) => {
+  const command = db.update(tables.account).set(input).where(eq(tables.account.id, id)).returning();
+  return { command };
+};
+
+const updateTransactionStatusCommand = async (db, transactionId, status, completedAt) => {
+  const updateData = {
+    status,
+    updatedAt: /* @__PURE__ */ new Date(),
+    ...completedAt && { completedAt }
+  };
+  const command = db.update(tables.transaction).set(updateData).where(eq(tables.transaction.id, transactionId)).returning();
+  return { command };
+};
+
+const updateTransactionConfirmationSentAtCommand = ({
+  db,
+  transactionId,
+  confirmationSentAt
+}) => {
+  const command = db.update(tables.transaction).set({ confirmationSentAt, updatedAt: /* @__PURE__ */ new Date() }).where(eq(tables.transaction.id, transactionId));
+  return {
+    command
+  };
+};
+
+const findAccountByIdentifierQuery = async (db, searchParams) => {
+  const conditions = [];
+  if (searchParams.iban) {
+    conditions.push(eq(tables.accountIdentifier.iban, searchParams.iban));
+  }
+  if (searchParams.accountNumber && searchParams.bankCode) {
+    conditions.push(
+      and(
+        eq(tables.accountIdentifier.accountNumber, searchParams.accountNumber),
+        eq(tables.accountIdentifier.bankCode, searchParams.bankCode)
+      )
+    );
+  }
+  if (searchParams.swift) {
+    conditions.push(eq(tables.accountIdentifier.swift, searchParams.swift));
+  }
+  if (searchParams.cryptoAddress) {
+    conditions.push(
+      eq(tables.accountIdentifier.cryptoAddress, searchParams.cryptoAddress)
+    );
+  }
+  if (conditions.length === 0) return void 0;
+  const result = await db.select({
+    account: tables.account,
+    identifier: tables.accountIdentifier
+  }).from(tables.accountIdentifier).innerJoin(
+    tables.accountIdentifierMapping,
+    eq(
+      tables.accountIdentifier.id,
+      tables.accountIdentifierMapping.identifierId
+    )
+  ).innerJoin(
+    tables.account,
+    eq(tables.accountIdentifierMapping.accountId, tables.account.id)
+  ).where(
+    inArray(
+      tables.account.id,
+      db.select({ accountId: tables.account.id }).from(tables.accountIdentifier).innerJoin(
+        tables.accountIdentifierMapping,
+        eq(
+          tables.accountIdentifier.id,
+          tables.accountIdentifierMapping.identifierId
+        )
+      ).innerJoin(
+        tables.account,
+        eq(tables.accountIdentifierMapping.accountId, tables.account.id)
+      ).where(or(...conditions))
+    )
+  );
+  if (result.length === 0) return void 0;
+  const account = result[0].account;
+  const identifiers = result.map((row) => ({
+    identifierId: row.identifier.id,
+    accountId: account.id
+  }));
+  return {
+    ...account,
+    identifiers
+  };
+};
+
+const getAccountBalanceByIdQuery = async (db, accountId) => {
+  const entries = await db.select().from(tables.entry).where(eq(tables.entry.accountId, accountId));
+  return entries.map((entry) => {
+    return entry.creditAmount - entry.debitAmount;
+  }).reduce((acc, curr) => acc + curr, 0);
+};
+
+const getAccountByIdQuery = async (db, id) => {
+  return await db.select().from(tables.account).where(eq(tables.account.id, id)).then(first);
+};
+
+const getAccountIdentifierByIdQuery = async (db, id) => {
+  return await db.select().from(tables.accountIdentifier).where(eq(tables.accountIdentifier.id, id)).then(first);
+};
+
+const getAccountWithIdentifiersQuery = async (db, accountId) => {
+  const result = await db.select({
+    account: tables.account,
+    identifier: tables.accountIdentifier
+  }).from(tables.account).innerJoin(
+    tables.accountIdentifierMapping,
+    eq(tables.account.id, tables.accountIdentifierMapping.accountId)
+  ).innerJoin(
+    tables.accountIdentifier,
+    eq(
+      tables.accountIdentifierMapping.identifierId,
+      tables.accountIdentifier.id
+    )
+  ).where(eq(tables.account.id, accountId));
+  if (result.length === 0) return void 0;
+  const account = result[0].account;
+  const identifiers = result.map((row) => row.identifier);
+  return {
+    ...account,
+    identifiers: identifiers.map((identifier) => ({
+      identifierId: identifier.id,
+      accountId
+    }))
+  };
+};
+
+const getAccountsByOwnerQuery = async (db, ownerId) => {
+  return await db.select().from(tables.account).where(eq(tables.account.ownerId, ownerId));
+};
+
+const getTransactionByIdQuery = async (db, id) => {
+  return await db.select().from(tables.transaction).where(eq(tables.transaction.id, id)).then(first);
+};
+
+const getTransactionsByCorrelationIdQuery = async (db, correlationId) => {
+  return await db.select().from(tables.transaction).where(eq(tables.transaction.correlationId, correlationId)).execute();
+};
+
+const getTransactionsByReferenceIdQuery = async (db, referenceType, referenceId) => {
+  return await db.select().from(tables.transaction).where(
+    and(
+      eq(tables.transaction.referenceType, referenceType),
+      eq(tables.transaction.referenceId, referenceId)
+    )
+  ).execute();
+};
+
+const listAccountIdentifiersQuery = async (db, accountId) => {
+  const result = await db.select({
+    identifier: tables.accountIdentifier
+  }).from(tables.accountIdentifierMapping).innerJoin(
+    tables.accountIdentifier,
+    eq(
+      tables.accountIdentifierMapping.identifierId,
+      tables.accountIdentifier.id
+    )
+  ).where(eq(tables.accountIdentifierMapping.accountId, accountId));
+  return result.map((row) => row.identifier);
+};
+
+const listAccountsQuery = async (db, filters = {}, pagination = { limit: 100, offset: 0 }) => {
+  const conditions = [];
+  if (filters.ownerId) {
+    conditions.push(eq(tables.account.ownerId, filters.ownerId));
+  }
+  if (filters.accountType) {
+    conditions.push(eq(tables.account.accountType, filters.accountType));
+  }
+  if (filters.assetType) {
+    conditions.push(eq(tables.account.assetType, filters.assetType));
+  }
+  if (filters.currency) {
+    conditions.push(eq(tables.account.currency, filters.currency));
+  }
+  if (filters.parentAccountId) {
+    conditions.push(eq(tables.account.parentAccountId, filters.parentAccountId));
+  }
+  const whereClause = conditions.length > 0 ? and(...conditions) : void 0;
+  const [{ total }] = await db.select({ total: count() }).from(tables.account).where(whereClause);
+  const accounts = await db.select().from(tables.account).where(whereClause).limit(pagination.limit).offset(pagination.offset);
+  return { accounts, total };
+};
+
+const buildSearchConditions = (search, columns, opts = {}) => {
+  const { wrap = "both" } = opts;
+  if (!search || search.trim() === "" || columns.length === 0) return void 0;
+  const searchTerm = search.toLowerCase();
+  const pattern = wrap === "both" ? `%${searchTerm}%` : wrap === "prefix" ? `%${searchTerm}` : wrap === "suffix" ? `${searchTerm}%` : searchTerm;
+  const parts = columns.map((col) => sql`LOWER(${col} || '') LIKE ${pattern}`);
+  return parts.length === 1 ? parts[0] : or(...parts);
+};
+
+const resolveColumn = (table, column, fallback = "updatedAt") => {
+  const key = column && column in table ? column : fallback;
+  return table[key];
+};
+
+const getTransactionsWithPaginationQuery = async ({
+  db,
+  pagination: {
+    limit,
+    page,
+    sort,
+    filterTransactionCorrelationId,
+    filterTransactionReferenceType,
+    filterTransactionReferenceId,
+    filterTransactionType,
+    filterTransactionDescription,
+    filterTransactionDateFrom,
+    filterTransactionDateTo,
+    filterTransactionCompletedAt,
+    filterTransactionStatus,
+    search
+  }
+}) => {
+  const searchConditions = buildSearchConditions(search, [
+    tables.transaction.status,
+    tables.transaction.description,
+    tables.transaction.type,
+    tables.transaction.referenceId,
+    tables.transaction.correlationId
+  ]);
+  const whereConditions = and(
+    searchConditions ? searchConditions : void 0,
+    filterTransactionCorrelationId ? eq(tables.transaction.correlationId, filterTransactionCorrelationId) : void 0,
+    filterTransactionReferenceType ? eq(tables.transaction.referenceType, filterTransactionReferenceType) : void 0,
+    filterTransactionReferenceId ? eq(tables.transaction.referenceId, filterTransactionReferenceId) : void 0,
+    filterTransactionType ? eq(tables.transaction.type, filterTransactionType) : void 0,
+    filterTransactionDescription ? eq(tables.transaction.description, filterTransactionDescription) : void 0,
+    filterTransactionDateFrom ? gte(tables.transaction.createdAt, filterTransactionDateFrom) : void 0,
+    filterTransactionDateTo ? lte(tables.transaction.createdAt, filterTransactionDateTo) : void 0,
+    filterTransactionCompletedAt ? eq(tables.transaction.completedAt, filterTransactionCompletedAt) : void 0,
+    filterTransactionStatus ? eq(tables.transaction.status, filterTransactionStatus) : void 0
+  );
+  const sortColumn = resolveColumn(tables.transaction, sort.column);
+  const [{ totalCount }] = await db.select({ totalCount: sql`count(*)` }).from(tables.transaction).where(whereConditions);
+  const transactionIds = await db.select({ id: tables.transaction.id }).from(tables.transaction).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? asc(sortColumn) : desc(sortColumn));
+  if (transactionIds.length === 0) {
+    return {
+      transactions: [],
+      totalCount
+    };
+  }
+  const transactions = await db.select().from(tables.transaction).where(
+    inArray(
+      tables.transaction.id,
+      transactionIds.map((o) => o.id)
+    )
+  ).orderBy(sort.direction === "asc" ? asc(sortColumn) : desc(sortColumn));
+  return {
+    transactions,
+    totalCount
+  };
+};
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let LedgerServiceBase = class extends develitWorker(WorkerEntrypoint) {
+  constructor(ctx, env) {
+    super(ctx, env);
+    this.db = drizzle(this.env.LEDGER_D1, { schema: tables });
+  }
+  async queue(_batch) {
+  }
+  async createTransaction(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: createTransactionInputSchema
+      },
+      { successMessage: "Transaction successfully created." },
+      async (params) => {
+        const {
+          correlationId,
+          referenceType,
+          referenceId,
+          type,
+          description,
+          paymentId,
+          metadata
+          // TODO: entries will be implemented later
+          // entries: inputEntries,
+        } = params;
+        await getTransactionsByCorrelationIdQuery(
+          this.db,
+          correlationId
+        );
+        const transactionId = uuidv4();
+        const timestamp = /* @__PURE__ */ new Date();
+        const transaction = {
+          id: transactionId,
+          correlationId,
+          referenceType,
+          referenceId,
+          type,
+          description,
+          createdAt: timestamp,
+          completedAt: null,
+          status: "WAITING_FOR_PAYMENT",
+          //todo: get from input?
+          paymentId,
+          metadata,
+          updatedAt: timestamp
+        };
+        const [data, error] = await useResult(
+          this.db.insert(tables.transaction).values(transaction).returning().then(first)
+        );
+        if (error) {
+          throw createInternalError(null, {
+            message: "Failed to create transaction",
+            status: 500,
+            code: "INTERNAL_ERROR"
+          });
+        }
+        const result = {
+          transaction: data
+          // TODO: entries will be implemented later
+          // entries: createdEntries,
+        };
+        await this.pushToQueue(
+          this.env.QUEUE_BUS_QUEUE,
+          {
+            eventType: "LEDGER_TRANSACTION",
+            ledgerTransaction: result.transaction,
+            metadata: {
+              correlationId: uuidv4(),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        );
+        return {
+          transaction: result.transaction
+          // TODO: entries will be implemented later
+          // entries: result.entries,
+          // isBalanced: false,
+          // imbalancedCurrencies:
+          //   imbalancedCurrencies.length > 0 ? imbalancedCurrencies : undefined,
+        };
+      }
+    );
+  }
+  async updateTransaction(input) {
+    return this.handleAction(
+      { data: input, schema: updateTransactionInputSchema },
+      { successMessage: "Transaction successfully updated." },
+      async (params) => {
+        const { transactionId, status, completedAt } = params;
+        const existingTransaction = await getTransactionByIdQuery(
+          this.db,
+          transactionId
+        );
+        if (!existingTransaction) {
+          throw createInternalError(null, {
+            message: "Transaction not found",
+            status: 404,
+            code: "NOT_FOUND"
+          });
+        }
+        const { command } = await updateTransactionStatusCommand(
+          this.db,
+          transactionId,
+          status,
+          completedAt
+        );
+        const [updatedTransaction] = await this.db.batch([command]);
+        if (!updatedTransaction) {
+          throw createInternalError(null, {
+            message: "Failed to update transaction",
+            status: 500,
+            code: "INTERNAL_ERROR"
+          });
+        }
+        const transaction = first(updatedTransaction);
+        await this.pushToQueue(
+          this.env.QUEUE_BUS_QUEUE,
+          {
+            eventType: "LEDGER_TRANSACTION",
+            ledgerTransaction: transaction,
+            metadata: {
+              correlationId: uuidv4(),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        );
+        return transaction;
+      }
+    );
+  }
+  async getTransactionById(input) {
+    return this.handleAction(
+      { data: input, schema: getTransactionByIdInputSchema },
+      { successMessage: "Transaction successfully obtained." },
+      async (params) => {
+        const { id } = params;
+        const transaction = await getTransactionByIdQuery(this.db, id);
+        return transaction;
+      }
+    );
+  }
+  async getTransactionsByReferenceId(input) {
+    return this.handleAction(
+      { data: input, schema: getTransactionsByReferenceIdInputSchema },
+      { successMessage: "Transaction successfully obtained." },
+      async (params) => {
+        const { referenceType, referenceId } = params;
+        const transactions = await getTransactionsByReferenceIdQuery(
+          this.db,
+          referenceType,
+          referenceId
+        );
+        return transactions;
+      }
+    );
+  }
+  async getTransactions(input) {
+    return this.handleAction(
+      { data: input, schema: getTransactionsInputSchema },
+      { successMessage: "Transactions fetched successfully" },
+      async (pagination) => {
+        const { transactions, totalCount } = await getTransactionsWithPaginationQuery({
+          db: this.db,
+          pagination
+        });
+        return { transactions, totalCount };
+      }
+    );
+  }
+  async createAccount(input) {
+    return this.handleAction(
+      { data: input, schema: createAccountInputSchema },
+      { successMessage: "Account successfully created." },
+      async (params) => {
+        const { identifier, ...accountData } = params;
+        const { command } = await createAccountCommand(this.db, {
+          id: uuidv4(),
+          ...accountData,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+        const [[account]] = await this.db.batch([command]);
+        if (!account) {
+          throw createInternalError(null, {
+            message: "Failed to create account",
+            status: 500,
+            code: "INTERNAL_SERVER_ERROR"
+          });
+        }
+        if (identifier) {
+          const { command: command2 } = await createAccountIdentifierCommand(this.db, {
+            id: uuidv4(),
+            ...identifier,
+            createdAt: /* @__PURE__ */ new Date()
+          });
+          const [[accountIdentifier]] = await this.db.batch([command2]);
+          if (accountIdentifier) {
+            const { command: command3 } = await linkAccountIdentifierCommand(
+              this.db,
+              account.id,
+              accountIdentifier.id
+            );
+            await this.db.batch([command3]);
+          }
+          return { account, identifier: accountIdentifier };
+        }
+        return { account, identifier: void 0 };
+      }
+    );
+  }
+  async updateAccount(input) {
+    return this.handleAction(
+      { data: input, schema: updateAccountInputSchema },
+      { successMessage: "Account successfully updated." },
+      async (params) => {
+        const { accountId, ...updateData } = params;
+        if (Object.keys(input).length === 0) {
+          const account2 = await getAccountByIdQuery(this.db, accountId);
+          if (!account2) {
+            throw createInternalError(null, {
+              message: "Account not found or update failed",
+              status: 404,
+              code: "NOT_FOUND"
+            });
+          }
+          return account2;
+        }
+        const { command } = await updateAccountCommand(
+          this.db,
+          accountId,
+          updateData
+        );
+        const [account] = await this.db.batch([command]);
+        if (!account) {
+          throw createInternalError(null, {
+            message: "Account not found or update failed",
+            status: 404,
+            code: "NOT_FOUND"
+          });
+        }
+        return first(account);
+      }
+    );
+  }
+  async deleteAccount(input) {
+    return this.handleAction(
+      { data: input, schema: deleteAccountInputSchema },
+      { successMessage: "Account successfully deleted." },
+      async (params) => {
+        const { accountId } = params;
+        const { accountIdentifierMappingCommand, accountCommand } = await deleteAccountCommand(this.db, accountId);
+        const [result] = await this.db.batch([
+          accountIdentifierMappingCommand,
+          accountCommand
+        ]);
+        return result.success;
+      }
+    );
+  }
+  async getAccount(input) {
+    return this.handleAction(
+      { data: input, schema: getAccountInputSchema },
+      { successMessage: "Account successfully retrieved." },
+      async (params) => {
+        const { accountId } = params;
+        const account = await getAccountWithIdentifiersQuery(this.db, accountId);
+        if (!account) {
+          throw createInternalError(null, {
+            message: "Account not found",
+            status: 404,
+            code: "NOT_FOUND"
+          });
+        }
+        return account;
+      }
+    );
+  }
+  async getAccountsByOwner(input) {
+    return this.handleAction(
+      { data: input, schema: getAccountsByOwnerInputSchema },
+      { successMessage: "Accounts successfully retrieved." },
+      async (params) => {
+        const { ownerId } = params;
+        const accounts = await getAccountsByOwnerQuery(this.db, ownerId);
+        return accounts;
+      }
+    );
+  }
+  async listAccounts(input) {
+    return this.handleAction(
+      { data: input, schema: listAccountsInputSchema },
+      { successMessage: "Accounts successfully listed." },
+      async (params) => {
+        const {
+          ownerId,
+          accountType,
+          assetType,
+          currency,
+          parentAccountId,
+          limit,
+          offset
+        } = params;
+        const result = await listAccountsQuery(
+          this.db,
+          { ownerId, accountType, assetType, currency, parentAccountId },
+          { limit, offset }
+        );
+        return {
+          accounts: result.accounts,
+          total: result.total,
+          limit,
+          offset
+        };
+      }
+    );
+  }
+  async getAccountIdentifierById(input) {
+    return this.handleAction(
+      { data: input, schema: getAccountIdentifierInputSchema },
+      { successMessage: "Account identifier successfully retrieved." },
+      async (params) => {
+        const { identifierId } = params;
+        const identifier = await getAccountIdentifierByIdQuery(
+          this.db,
+          identifierId
+        );
+        if (!identifier) {
+          throw createInternalError(null, {
+            message: "Account identifier not found",
+            status: 404,
+            code: "NOT_FOUND"
+          });
+        }
+        return identifier;
+      }
+    );
+  }
+  async listAccountIdentifiers(input) {
+    return this.handleAction(
+      { data: input, schema: listAccountIdentifiersInputSchema },
+      { successMessage: "Account identifiers successfully listed." },
+      async (params) => {
+        const { accountId } = params;
+        const identifiers = await listAccountIdentifiersQuery(
+          this.db,
+          accountId
+        );
+        return identifiers;
+      }
+    );
+  }
+  async findAccountByIdentifier(input) {
+    return this.handleAction(
+      { data: input, schema: findAccountByIdentifierInputSchema },
+      { successMessage: "Account search completed." },
+      async (params) => {
+        const searchParams = params;
+        const account = await findAccountByIdentifierQuery(
+          this.db,
+          searchParams
+        );
+        return account;
+      }
+    );
+  }
+  async getAccountBalance(input) {
+    return this.handleAction(
+      { data: input, schema: getAccountBalanceInputSchema },
+      { successMessage: "Balance successfully obtained." },
+      async (params) => {
+        const { accountId } = params;
+        const account = await getAccountByIdQuery(this.db, accountId);
+        if (!account) {
+          throw new Error(`Account ${accountId} not found`);
+        }
+        const balance = await getAccountBalanceByIdQuery(this.db, accountId);
+        return { balance };
+      }
+    );
+  }
+  async updateTransactionConfirmationSentAt(input) {
+    return this.handleAction(
+      { data: input, schema: updateTransactionConfirmationSentAtInputSchema },
+      { successMessage: "Confirmation email sent successfully" },
+      async ({ transactionId }) => {
+        const { command: transactionCommand } = updateTransactionConfirmationSentAtCommand({
+          db: this.db,
+          transactionId,
+          confirmationSentAt: /* @__PURE__ */ new Date()
+        });
+        await this.db.batch([transactionCommand]);
+      }
+    );
+  }
+};
+__decorateClass([
+  cloudflareQueue({ baseDelay: 60 })
+], LedgerServiceBase.prototype, "queue", 1);
+__decorateClass([
+  action("create-transaction")
+], LedgerServiceBase.prototype, "createTransaction", 1);
+__decorateClass([
+  action("update-transaction")
+], LedgerServiceBase.prototype, "updateTransaction", 1);
+__decorateClass([
+  action("get-transaction-by-id")
+], LedgerServiceBase.prototype, "getTransactionById", 1);
+__decorateClass([
+  action("get-transactions-by-reference-id")
+], LedgerServiceBase.prototype, "getTransactionsByReferenceId", 1);
+__decorateClass([
+  action("get-transactions")
+], LedgerServiceBase.prototype, "getTransactions", 1);
+__decorateClass([
+  action("create-account")
+], LedgerServiceBase.prototype, "createAccount", 1);
+__decorateClass([
+  action("update-account")
+], LedgerServiceBase.prototype, "updateAccount", 1);
+__decorateClass([
+  action("delete-account")
+], LedgerServiceBase.prototype, "deleteAccount", 1);
+__decorateClass([
+  action("get-account")
+], LedgerServiceBase.prototype, "getAccount", 1);
+__decorateClass([
+  action("get-accounts-by-owner")
+], LedgerServiceBase.prototype, "getAccountsByOwner", 1);
+__decorateClass([
+  action("list-accounts")
+], LedgerServiceBase.prototype, "listAccounts", 1);
+__decorateClass([
+  action("get-account-identifier")
+], LedgerServiceBase.prototype, "getAccountIdentifierById", 1);
+__decorateClass([
+  action("list-account-identifiers")
+], LedgerServiceBase.prototype, "listAccountIdentifiers", 1);
+__decorateClass([
+  action("find-account-by-identifier")
+], LedgerServiceBase.prototype, "findAccountByIdentifier", 1);
+__decorateClass([
+  action("get-account-balance")
+], LedgerServiceBase.prototype, "getAccountBalance", 1);
+__decorateClass([
+  action("update-transaction-confirmation-sent-at")
+], LedgerServiceBase.prototype, "updateTransactionConfirmationSentAt", 1);
+LedgerServiceBase = __decorateClass([
+  service("ledger")
+], LedgerServiceBase);
+function defineLedgerService() {
+  return class LedgerService extends LedgerServiceBase {
+    constructor(ctx, env) {
+      super(ctx, env);
+    }
+  };
+}
+const LedgerService = defineLedgerService();
+
+export { LedgerService as default, defineLedgerService };