@cfxlabsinc/b2b-services
    Preparing search index...

    Class LedgerAccountQueryService

    Readonly access to a customer's ledger accounts.

    Extends LedgerAccountCache, which owns the ledger-account-search namespace this read shares with the admin surface, and the serialization that defines its stored shape.

    Hierarchy (View Summary)

    Index
    constructor
    cache db solanaAccountBalanceQueryService
    get getAggregateBalance getPublic groupByEntity invalidateCache search searchPublic searchTags deserializeLedgerAccount serializeLedgerAccount
    cache: ServiceCache<CachedSearchPage<CachedLedgerAccountSearchItem>>
    db: B2bDatabase
    solanaAccountBalanceQueryService: SolanaAccountBalanceQueryService

    • Get the given ledger account for the given customer

      Parameters

      • args: { customerId: string; id: string }

      Returns Promise<
          {
              ok: true;
              value: | {
                  address: Address;
                  balance: BigNumber;
                  createdAt: Date;
                  id: string;
                  name: string;
                  notes?: string;
                  paymentInstrumentId?: string;
                  permissions: "ADMIN"
                  | "ALL";
                  referenceId?: string;
                  tokenAccounts: Record<"MOVEUSD", { address: Address }>;
                  updatedAt: Date;
                  visibility: "PRIVATE" | "PUBLIC";
              } & {
                  customerOrganizationId: string;
                  entityDisplayName: string;
                  entityId: string;
                  entityReferenceId: string
                  | null;
                  entityType: "IDENTITY" | "ORGANIZATION";
              }
              | null;
          },
      >

    • Sum the balances of all ledger accounts for the given customer. Returns BigNumber(0) when the customer has no accounts.

      Parameters

      • __namedParameters: { customerId: string }

      Returns Promise<{ ok: true; value: { totalBalance: BigNumber } }>

    • Get a public ledger account that belongs to any customer

      Parameters

      • __namedParameters: { id: string }

      Returns Promise<
          | Omit<
              {
                  address: Address;
                  balance: BigNumber;
                  createdAt: Date;
                  id: string;
                  name: string;
                  notes?: string;
                  paymentInstrumentId?: string;
                  permissions: "ADMIN"
                  | "ALL";
                  referenceId?: string;
                  tokenAccounts: Record<"MOVEUSD", { address: Address }>;
                  updatedAt: Date;
                  visibility: "PRIVATE" | "PUBLIC";
              },
              "balance",
          > & { customer: { id: string; name: string } }
          | null,
      >

    • Return per-entity account metadata and counts for the given customer. One row per entity (identity or organization). main is true when the entity is the customer's primary organization.

      Parameters

      • __namedParameters: { customerId: string }

      Returns Promise<
          {
              ok: true;
              value: {
                  items: {
                      count: number;
                      customerOrganizationId: string;
                      entityDisplayName: string;
                      entityId: string;
                      entityReferenceId: string
                      | null;
                      entityType: "IDENTITY" | "ORGANIZATION";
                      main: boolean;
                  }[];
              };
          },
      >

    • Bust every cached page — consumer or admin — that a write touching customerIds could have affected.

      The collection tag is always cleared alongside, because an unscoped admin page carries only that tag and no customer id can reach it.

      keys deletes exact entries in addition to the tag surgery, passing the key arguments — this cache hashes and prefixes them. It exists because invalidateTag resolves keys through the FT index, which does not exist in memory mode (valkeyClient: null); there the tag bust is a total no-op, and an exact-key delete is the only thing that keeps read-after-write honest. Services that folded get onto search pass that get's arguments.

      These deletes only reach this instance's own key space, because the key space is partitioned per surface. That is sufficient, and a writer must not try to name the other surface's key:

      • With Valkey, the other surface's get entry is itself tagged (by customer id, or by the collection tag when unscoped), so the tag bust above already evicts it from the shared L2 and publishes the peer eviction.
      • Without Valkey, the two surfaces are separate instances with separate L1 maps, so deleting a key from this instance could never have affected the other one anyway.

      Parameters

      • __namedParameters: { customerIds: readonly string[]; keys?: readonly CacheKey[] }

      Returns Promise<void>

    • Search all customers' public ledger accounts

      Parameters

      • __namedParameters: {
            addresses?: Address[];
            customerIds?: string[];
            customerNameLike?: string;
            ids?: string[];
        }

      Returns Promise<
          (
              Omit<
                  {
                      address: Address;
                      balance: BigNumber;
                      createdAt: Date;
                      id: string;
                      name: string;
                      notes?: string;
                      paymentInstrumentId?: string;
                      permissions: "ADMIN"
                      | "ALL";
                      referenceId?: string;
                      tokenAccounts: Record<"MOVEUSD", { address: Address }>;
                      updatedAt: Date;
                      visibility: "PRIVATE" | "PUBLIC";
                  },
                  "balance",
              > & { customer: { id: string; name: string } }
          )[],
      >

    • Tags to write on a page, derived from the scope the query searched — never from the customers present in the result.

      That distinction is load-bearing. An entry tagged with the customer ids in the page carries no tags when the page is empty, so nothing can ever bust it and a later create leaves it stale for the full L2 TTL. Tagging by scope means an empty page still carries the tag for what it searched.

      An unscoped read falls back to the collection tag, since no customer-id tag can reach a row whose owner did not exist when the entry was written.

      Parameters

      • __namedParameters: { customerIds: readonly string[] | undefined }

      Returns string[]

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Methods