@fintekkers/ledger-models 0.4.10 → 0.4.11

package/node/wrappers/util/link-resolver.test.ts

@@ -1,6 +1,7 @@
 import LinkResolver from './link-resolver';
 import Price from '../models/price/Price';
 import { UUID } from '../models/utils/uuid';
+import * as LinkCacheModuleTop from './link-cache';
 
 import { SecurityProto } from '../../fintekkers/models/security/security_pb';
 import { PortfolioProto } from '../../fintekkers/models/portfolio/portfolio_pb';
@@ -121,6 +122,14 @@ function linkPrice(securityUuid: UUID, priceValue: string, asOf?: LocalTimestamp
 }
 
 describe('LinkResolver', () => {
+  // Process-wide LinkCache singletons survive across tests, so clear them
+  // between cases to keep tests independent (post-W4 the resolver no longer
+  // owns its own cache).
+  beforeEach(() => {
+    LinkCacheModuleTop.SECURITY.clear();
+    LinkCacheModuleTop.PORTFOLIO.clear();
+  });
+
   test('bulk resolveSecurities dedupes UUIDs (5 prices, 3 unique → 1 RPC, 3 UUIDs)', async () => {
     const uuidA = UUID.random();
     const uuidB = UUID.random();
@@ -203,7 +212,10 @@ describe('LinkResolver', () => {
     for (const r of results) expect(r.getIssuerName()).toBe('AAPL');
   });
 
-  test('caching disabled (cacheSize=0) re-RPCs every call', async () => {
+  test('LinkCache evict between calls forces refetch', async () => {
+    // Post-W4 the resolver no longer owns its cache. Evict the entry from
+    // LinkCache.SECURITY between calls to force a refetch — the equivalent
+    // of the old `cacheSize=0` semantic.
     const uuid = UUID.random();
     const store = new Map<string, SecurityProto>([
       [uuid.toString(), fullSecurity(uuid, 'AAPL')],
@@ -211,12 +223,12 @@ describe('LinkResolver', () => {
     const callLog = newCallLog();
 
     const resolver = new LinkResolver({
-      cacheSize: 0,
       securityClient: mockSecurityClient(store, callLog),
       portfolioClient: mockPortfolioClient(new Map(), newCallLog()),
     });
 
     await resolver.getSecurity(uuid);
+    LinkCacheModuleTop.SECURITY.evict(uuid.toString());
     await resolver.getSecurity(uuid);
 
     expect(callLog.count).toBe(2);

package/node/wrappers/util/link-resolver.ts

@@ -2,78 +2,50 @@ import { promisify } from 'util';
 
 import { SecurityProto } from '../../fintekkers/models/security/security_pb';
 import { PortfolioProto } from '../../fintekkers/models/portfolio/portfolio_pb';
+import { TransactionProto } from '../../fintekkers/models/transaction/transaction_pb';
 import { UUIDProto } from '../../fintekkers/models/util/uuid_pb';
 import { LocalTimestampProto } from '../../fintekkers/models/util/local_timestamp_pb';
 
 import { SecurityClient } from '../../fintekkers/services/security-service/security_service_grpc_pb';
 import { PortfolioClient } from '../../fintekkers/services/portfolio-service/portfolio_service_grpc_pb';
+import { TransactionClient } from '../../fintekkers/services/transaction-service/transaction_service_grpc_pb';
 import { QuerySecurityRequestProto } from '../../fintekkers/requests/security/query_security_request_pb';
 import { QuerySecurityResponseProto } from '../../fintekkers/requests/security/query_security_response_pb';
 import { QueryPortfolioRequestProto } from '../../fintekkers/requests/portfolio/query_portfolio_request_pb';
 import { QueryPortfolioResponseProto } from '../../fintekkers/requests/portfolio/query_portfolio_response_pb';
+import { QueryTransactionRequestProto } from '../../fintekkers/requests/transaction/query_transaction_request_pb';
+import { QueryTransactionResponseProto } from '../../fintekkers/requests/transaction/query_transaction_response_pb';
 
 import Security from '../models/security/security';
 import Portfolio from '../models/portfolio/portfolio';
+import Transaction from '../models/transaction/transaction';
 import { UUID } from '../models/utils/uuid';
 import EnvConfig from '../models/utils/requestcontext';
 import { ZonedDateTime } from '../models/utils/datetime';
 import * as LinkCacheModule from './link-cache';
 
-/**
- * Mirror a freshly-fetched SecurityProto into the process-wide
- * `LinkCache.SECURITY`. The lazy-hydrate `SecurityWrapper.ensureHydrated()`
- * reads from this cache, so pre-warming via LinkResolver immediately
- * benefits accessor reads. Skips silently when the resolved proto lacks
- * uuid or as_of — `LinkCache.put` requires both.
- */
-function populateSecurityLinkCache(proto: SecurityProto): void {
-  const uuidProto = proto.getUuid();
-  const asOfProto = proto.getAsOf();
-  if (!uuidProto || !asOfProto) return;
-  const uuidKey = UUID.fromU8Array(uuidProto.getRawUuid_asU8()).toString();
-  LinkCacheModule.SECURITY.put(uuidKey, proto, new ZonedDateTime(asOfProto));
-}
-
-function populatePortfolioLinkCache(proto: PortfolioProto): void {
-  const uuidProto = proto.getUuid();
-  const asOfProto = proto.getAsOf();
-  if (!uuidProto || !asOfProto) return;
-  const uuidKey = UUID.fromU8Array(uuidProto.getRawUuid_asU8()).toString();
-  LinkCacheModule.PORTFOLIO.put(uuidKey, proto, new ZonedDateTime(asOfProto));
-}
-
 /**
  * LinkResolver — bulk hydration of `is_link=true` entity references into
  * full entities. Implements the consumer side of the `is_link` pattern
  * documented in `docs/adr/is_link_pattern.md`.
  *
+ * W4: the resolver no longer owns its own LRU. Cache reads/writes route
+ * through the process-wide `LinkCache.SECURITY` / `LinkCache.PORTFOLIO`
+ * singletons. The resolver still does concurrent-call dedup (single
+ * in-flight RPC per (uuid, as_of)) and bulk per-bucket batching; storage
+ * and eviction live in LinkCache.
+ *
  * Two surface methods:
  *   - getSecurity(uuid) / getPortfolio(uuid): single-UUID resolution. Cached
  *     and concurrent-deduped.
  *   - resolveSecurities(items) / resolvePortfolios(items): bulk in-place
  *     mutation across a heterogeneous list of items that each have a
  *     proto-style getter+setter for the embedded entity. Collects unique
- *     link UUIDs, fires one batched GetByIds RPC, mutates each item's proto
- *     to swap the link sub-message for the resolved full entity (with
- *     is_link=false on the embedded copy).
- *
- * Caching:
- *   - Process-level LRU keyed on UUID string. Default 1000 entries, no TTL
- *     (entries live until evicted by LRU). Long-running services that need
- *     freshness should pass `{ ttlMs: <ms> }`. Tests can disable with
- *     `{ cacheSize: 0 }`.
- *   - Concurrent same-UUID requests are deduped via an in-flight promise
- *     map — N parallel callers for the same UUID share one RPC.
+ *     link UUIDs, fires one batched GetByIds RPC per as_of bucket, mutates
+ *     each item's proto to swap the link sub-message for the resolved
+ *     full entity.
  *
- * RPC choice: uses `GetByIds` (unary, UUID-keyed bulk) per the ADR. The
- * existing `SecurityService.search` (streaming) would also work but
- * requires more wrapper plumbing for batched-by-UUID semantics.
- *
- * Mutation semantic: when bulk-resolving, the embedded sub-message is
- * replaced (not the outer entity). Outer Price.proto.is_link is unchanged;
- * only the inner SecurityProto is swapped from link-stub to full entity.
- * Wrapper objects that read through the proto (`price.getSecurity()`)
- * automatically see the resolved data.
+ * RPC choice: uses `GetByIds` (unary, UUID-keyed bulk) per the ADR.
  *
  * Time-travel (`as_of`) semantic: per is_link_pattern.md addendum, when
  * a link sub-message has only `uuid` set the resolver fetches the latest
@@ -86,104 +58,74 @@ function populatePortfolioLinkCache(proto: PortfolioProto): void {
 export interface LinkResolverOptions {
   /** Optional API key. If omitted, EnvConfig.apiCredentials is used. */
   apiKey?: string;
-  /** LRU max entries. Default 1000. Set to 0 to disable caching. */
-  cacheSize?: number;
-  /** Per-entry TTL in ms. Default undefined (no expiry). */
-  ttlMs?: number;
   /**
    * Test injection: clients to use instead of constructing real ones.
    * Production callers should not set these.
    */
   securityClient?: SecurityClient;
   portfolioClient?: PortfolioClient;
-}
-
-interface CacheEntry<V> {
-  value: V;
-  insertedAt: number;
+  transactionClient?: TransactionClient;
 }
 
 /**
- * Tiny LRU. Map keeps insertion order; on get-hit we delete + re-insert
- * to bump to the end (most recently used). On overflow we drop the
- * oldest entry (first key in the Map). Avoids pulling in lru-cache as a
- * dependency for ~30 lines of logic.
- */
-class TinyLRU<V> {
-  private map = new Map<string, CacheEntry<V>>();
-  constructor(private maxSize: number, private ttlMs?: number) {}
-
-  get(key: string): V | undefined {
-    if (this.maxSize === 0) return undefined;
-    const entry = this.map.get(key);
-    if (!entry) return undefined;
-    if (this.ttlMs !== undefined && Date.now() - entry.insertedAt > this.ttlMs) {
-      this.map.delete(key);
-      return undefined;
-    }
-    // Bump to most-recently-used.
-    this.map.delete(key);
-    this.map.set(key, entry);
-    return entry.value;
-  }
-
-  set(key: string, value: V): void {
-    if (this.maxSize === 0) return;
-    if (this.map.has(key)) this.map.delete(key);
-    this.map.set(key, { value, insertedAt: Date.now() });
-    while (this.map.size > this.maxSize) {
-      const oldest = this.map.keys().next().value;
-      if (oldest === undefined) break;
-      this.map.delete(oldest);
-    }
-  }
-
-  size(): number {
-    return this.map.size;
-  }
-
-  clear(): void {
-    this.map.clear();
-  }
-}
-
-/**
- * Stable serialization of a LocalTimestampProto for use in cache keys
- * and as_of-bucket grouping. Uses the proto's binary form (Uint8Array
+ * Stable serialization of a LocalTimestampProto for use in in-flight dedup
+ * keys and as_of-bucket grouping. Uses the proto's binary form (Uint8Array
  * → base64). Returns the literal "latest" when as_of is undefined so
  * unset and explicit-undefined collapse to the same bucket.
- *
- * Two LocalTimestampProto instances representing the same moment will
- * produce the same key as long as the underlying nanos/seconds match —
- * proto3 binary encoding is canonical for unset fields.
  */
 function asOfKey(asOf: LocalTimestampProto | undefined): string {
   if (!asOf) return 'latest';
-  // serializeBinary returns Uint8Array.
   const bytes = asOf.serializeBinary();
   return Buffer.from(bytes).toString('base64');
 }
 
+function asOfToZdt(asOf: LocalTimestampProto | undefined): ZonedDateTime | null {
+  return asOf ? new ZonedDateTime(asOf) : null;
+}
+
+// Process-wide default singleton — lazily constructed on first
+// `LinkResolver.getDefault()` call. Used by the wrapper `hydrate()`
+// methods so callers don't have to thread a resolver instance through
+// their code. Override the default by calling `LinkResolver.setDefault(...)`
+// at process start (tests with mocked clients, alternate endpoints, etc.).
+let defaultLinkResolver: LinkResolver | undefined;
+
 class LinkResolver {
   private securityClient: SecurityClient;
   private portfolioClient: PortfolioClient;
-
-  private securityCache: TinyLRU<SecurityProto>;
-  private portfolioCache: TinyLRU<PortfolioProto>;
+  private transactionClient: TransactionClient;
 
   // Concurrent-call dedupe: a UUID currently being fetched maps to the
   // promise the *first* caller is awaiting. Subsequent callers for the
   // same UUID receive that same promise.
   private securityInFlight = new Map<string, Promise<SecurityProto>>();
   private portfolioInFlight = new Map<string, Promise<PortfolioProto>>();
+  private transactionInFlight = new Map<string, Promise<TransactionProto>>();
 
-  constructor(opts: LinkResolverOptions = {}) {
-    const cacheSize = opts.cacheSize ?? 1000;
-    const ttlMs = opts.ttlMs;
+  /**
+   * Process-wide singleton — lazily constructed with default options
+   * (env-derived endpoint via `EnvConfig`). The wrapper `hydrate()`
+   * methods reach for this when no resolver is passed explicitly, so
+   * users get auto-resolve on link-mode wrappers without threading a
+   * resolver through every call site.
+   */
+  static getDefault(): LinkResolver {
+    if (!defaultLinkResolver) {
+      defaultLinkResolver = new LinkResolver();
+    }
+    return defaultLinkResolver;
+  }
 
-    this.securityCache = new TinyLRU(cacheSize, ttlMs);
-    this.portfolioCache = new TinyLRU(cacheSize, ttlMs);
+  /**
+   * Replace the process-wide default. Call once at process start for
+   * tests with mocked clients or to point at a non-default endpoint.
+   * Pass `undefined` to clear (next `getDefault()` call rebuilds).
+   */
+  static setDefault(resolver: LinkResolver | undefined): void {
+    defaultLinkResolver = resolver;
+  }
 
+  constructor(opts: LinkResolverOptions = {}) {
     if (opts.securityClient) {
       this.securityClient = opts.securityClient;
     } else if (opts.apiKey) {
@@ -201,6 +143,15 @@ class LinkResolver {
     } else {
       this.portfolioClient = new PortfolioClient(EnvConfig.apiURL, EnvConfig.apiCredentials);
     }
+
+    if (opts.transactionClient) {
+      this.transactionClient = opts.transactionClient;
+    } else if (opts.apiKey) {
+      const { credentials, interceptors } = EnvConfig.getAuthenticatedClientOptions(opts.apiKey);
+      this.transactionClient = new TransactionClient(EnvConfig.apiURL, credentials, { interceptors });
+    } else {
+      this.transactionClient = new TransactionClient(EnvConfig.apiURL, EnvConfig.apiCredentials);
+    }
   }
 
   /**
@@ -223,6 +174,15 @@ class LinkResolver {
     return new Portfolio(proto);
   }
 
+  /**
+   * Resolve a single TransactionProto by UUID, optionally as of `asOf`.
+   * Cached + concurrent-deduped on (uuid, asOf).
+   */
+  async getTransaction(uuid: UUID, asOf?: LocalTimestampProto): Promise<Transaction> {
+    const proto = await this.fetchTransactionProto(uuid, asOf);
+    return new Transaction(proto);
+  }
+
   /**
    * Walk `items`, find the ones whose embedded security is `is_link=true`,
    * batch-fetch the unique (uuid, as_of) pairs (grouped by as_of so each
@@ -230,17 +190,13 @@ class LinkResolver {
    * place so subsequent `item.getSecurity()` calls return the full entity.
    * Returns the same array for chaining.
    *
-   * Honors per-link `as_of`: if the embedded sub-message has `as_of` set,
-   * the resolver fetches the version of the entity at that timestamp,
-   * not the latest.
-   *
    * `T` is structural: anything with a `proto` field that exposes
    * `getSecurity()` / `setSecurity()` works (Price, Transaction, etc).
    */
   async resolveSecurities<T extends ResolvableSecurity>(items: T[]): Promise<T[]> {
     if (items.length === 0) return items;
 
-    // Group: as_of bucket → (cacheKey → UUID) for items not yet cached.
+    // Group: as_of bucket → (uuid string → UUID) for items not yet cached.
     const buckets = new Map<string, Map<string, UUID>>();
     for (const item of items) {
       const sec = item.proto.getSecurity();
@@ -249,32 +205,28 @@ class LinkResolver {
       if (!uuidProto) continue;
       const uuid = UUID.fromU8Array(uuidProto.getRawUuid_asU8());
       const asOf = sec.getAsOf();
+      const uuidStr = uuid.toString();
+      if (LinkCacheModule.SECURITY.get(uuidStr, asOfToZdt(asOf))) continue;
       const bucketKey = asOfKey(asOf);
-      const cacheKey = `${uuid.toString()}@${bucketKey}`;
-      // Skip if already cached for this exact (uuid, as_of).
-      if (this.securityCache.get(cacheKey)) continue;
       let bucket = buckets.get(bucketKey);
       if (!bucket) {
         bucket = new Map<string, UUID>();
         buckets.set(bucketKey, bucket);
       }
-      if (!bucket.has(cacheKey)) bucket.set(cacheKey, uuid);
+      if (!bucket.has(uuidStr)) bucket.set(uuidStr, uuid);
     }
 
     // One GetByIds RPC per as_of bucket. Fire in parallel.
     await Promise.all(
       Array.from(buckets.entries()).map(async ([bucketKey, uuidMap]) => {
-        // Recover the LocalTimestampProto for this bucket from the first
-        // item whose serialized as_of matches. We could store it alongside
-        // but it's cheap to re-find.
-        const asOf = bucketKey === 'latest' ? undefined : findAsOfForBucket(items, (sec) => sec.getSecurity(), bucketKey);
+        const asOf = bucketKey === 'latest' ? undefined : findAsOfForBucket(items, (proto) => proto.getSecurity(), bucketKey);
+        const asOfZdt = asOfToZdt(asOf);
         const fetched = await this.batchFetchSecurities(Array.from(uuidMap.values()), asOf);
         for (const proto of fetched) {
           const uuidProto = proto.getUuid();
           if (!uuidProto) continue;
           const uuidStr = UUID.fromU8Array(uuidProto.getRawUuid_asU8()).toString();
-          this.securityCache.set(`${uuidStr}@${bucketKey}`, proto);
-          populateSecurityLinkCache(proto);
+          LinkCacheModule.SECURITY.put(uuidStr, proto, asOfZdt);
         }
       }),
     );
@@ -286,8 +238,7 @@ class LinkResolver {
       const uuidProto = sec.getUuid();
       if (!uuidProto) continue;
       const uuidStr = UUID.fromU8Array(uuidProto.getRawUuid_asU8()).toString();
-      const bucketKey = asOfKey(sec.getAsOf());
-      const resolved = this.securityCache.get(`${uuidStr}@${bucketKey}`);
+      const resolved = LinkCacheModule.SECURITY.get(uuidStr, asOfToZdt(sec.getAsOf()));
       if (resolved) item.proto.setSecurity(resolved);
     }
 
@@ -309,27 +260,27 @@ class LinkResolver {
       if (!uuidProto) continue;
       const uuid = UUID.fromU8Array(uuidProto.getRawUuid_asU8());
       const asOf = port.getAsOf();
+      const uuidStr = uuid.toString();
+      if (LinkCacheModule.PORTFOLIO.get(uuidStr, asOfToZdt(asOf))) continue;
       const bucketKey = asOfKey(asOf);
-      const cacheKey = `${uuid.toString()}@${bucketKey}`;
-      if (this.portfolioCache.get(cacheKey)) continue;
       let bucket = buckets.get(bucketKey);
       if (!bucket) {
         bucket = new Map<string, UUID>();
         buckets.set(bucketKey, bucket);
       }
-      if (!bucket.has(cacheKey)) bucket.set(cacheKey, uuid);
+      if (!bucket.has(uuidStr)) bucket.set(uuidStr, uuid);
     }
 
     await Promise.all(
       Array.from(buckets.entries()).map(async ([bucketKey, uuidMap]) => {
-        const asOf = bucketKey === 'latest' ? undefined : findAsOfForBucket(items, (it) => it.getPortfolio(), bucketKey);
+        const asOf = bucketKey === 'latest' ? undefined : findAsOfForBucket(items, (proto) => proto.getPortfolio(), bucketKey);
+        const asOfZdt = asOfToZdt(asOf);
         const fetched = await this.batchFetchPortfolios(Array.from(uuidMap.values()), asOf);
         for (const proto of fetched) {
           const uuidProto = proto.getUuid();
           if (!uuidProto) continue;
           const uuidStr = UUID.fromU8Array(uuidProto.getRawUuid_asU8()).toString();
-          this.portfolioCache.set(`${uuidStr}@${bucketKey}`, proto);
-          populatePortfolioLinkCache(proto);
+          LinkCacheModule.PORTFOLIO.put(uuidStr, proto, asOfZdt);
         }
       }),
     );
@@ -340,40 +291,40 @@ class LinkResolver {
       const uuidProto = port.getUuid();
       if (!uuidProto) continue;
       const uuidStr = UUID.fromU8Array(uuidProto.getRawUuid_asU8()).toString();
-      const bucketKey = asOfKey(port.getAsOf());
-      const resolved = this.portfolioCache.get(`${uuidStr}@${bucketKey}`);
+      const resolved = LinkCacheModule.PORTFOLIO.get(uuidStr, asOfToZdt(port.getAsOf()));
       if (resolved) item.proto.setPortfolio(resolved);
     }
 
     return items;
   }
 
-  /** Test/debug helper. Not part of the stable API. */
+  /** Test/debug helper. Clears in-flight maps; the process-wide LinkCache
+   * is left alone (tests that need to drop a specific cached entry call
+   * `LinkCache.SECURITY.evict(uuid)` directly). */
   clearCache(): void {
-    this.securityCache.clear();
-    this.portfolioCache.clear();
     this.securityInFlight.clear();
     this.portfolioInFlight.clear();
+    this.transactionInFlight.clear();
   }
 
   // ---------- internals ----------
 
   private async fetchSecurityProto(uuid: UUID, asOf?: LocalTimestampProto): Promise<SecurityProto> {
-    const key = `${uuid.toString()}@${asOfKey(asOf)}`;
-
-    const cached = this.securityCache.get(key);
+    const uuidStr = uuid.toString();
+    const asOfZdt = asOfToZdt(asOf);
+    const cached = LinkCacheModule.SECURITY.get(uuidStr, asOfZdt);
     if (cached) return cached;
 
+    const key = `${uuidStr}@${asOfKey(asOf)}`;
     const inFlight = this.securityInFlight.get(key);
     if (inFlight) return inFlight;
 
     const promise = this.batchFetchSecurities([uuid], asOf).then((protos) => {
       if (protos.length === 0) {
-        throw new Error(`Security not found: ${uuid.toString()}@${asOfKey(asOf)}`);
+        throw new Error(`Security not found: ${key}`);
       }
       const proto = protos[0];
-      this.securityCache.set(key, proto);
-      populateSecurityLinkCache(proto);
+      LinkCacheModule.SECURITY.put(uuidStr, proto, asOfZdt);
       return proto;
     }).finally(() => {
       this.securityInFlight.delete(key);
@@ -384,21 +335,21 @@ class LinkResolver {
   }
 
   private async fetchPortfolioProto(uuid: UUID, asOf?: LocalTimestampProto): Promise<PortfolioProto> {
-    const key = `${uuid.toString()}@${asOfKey(asOf)}`;
-
-    const cached = this.portfolioCache.get(key);
+    const uuidStr = uuid.toString();
+    const asOfZdt = asOfToZdt(asOf);
+    const cached = LinkCacheModule.PORTFOLIO.get(uuidStr, asOfZdt);
     if (cached) return cached;
 
+    const key = `${uuidStr}@${asOfKey(asOf)}`;
     const inFlight = this.portfolioInFlight.get(key);
     if (inFlight) return inFlight;
 
     const promise = this.batchFetchPortfolios([uuid], asOf).then((protos) => {
       if (protos.length === 0) {
-        throw new Error(`Portfolio not found: ${uuid.toString()}@${asOfKey(asOf)}`);
+        throw new Error(`Portfolio not found: ${key}`);
       }
       const proto = protos[0];
-      this.portfolioCache.set(key, proto);
-      populatePortfolioLinkCache(proto);
+      LinkCacheModule.PORTFOLIO.put(uuidStr, proto, asOfZdt);
       return proto;
     }).finally(() => {
       this.portfolioInFlight.delete(key);
@@ -408,6 +359,31 @@ class LinkResolver {
     return promise;
   }
 
+  private async fetchTransactionProto(uuid: UUID, asOf?: LocalTimestampProto): Promise<TransactionProto> {
+    const uuidStr = uuid.toString();
+    const asOfZdt = asOfToZdt(asOf);
+    const cached = LinkCacheModule.TRANSACTION.get(uuidStr, asOfZdt);
+    if (cached) return cached;
+
+    const key = `${uuidStr}@${asOfKey(asOf)}`;
+    const inFlight = this.transactionInFlight.get(key);
+    if (inFlight) return inFlight;
+
+    const promise = this.batchFetchTransactions([uuid], asOf).then((protos) => {
+      if (protos.length === 0) {
+        throw new Error(`Transaction not found: ${key}`);
+      }
+      const proto = protos[0];
+      LinkCacheModule.TRANSACTION.put(uuidStr, proto, asOfZdt);
+      return proto;
+    }).finally(() => {
+      this.transactionInFlight.delete(key);
+    });
+
+    this.transactionInFlight.set(key, promise);
+    return promise;
+  }
+
   private async batchFetchSecurities(uuids: UUID[], asOf?: LocalTimestampProto): Promise<SecurityProto[]> {
     if (uuids.length === 0) return [];
     const request = new QuerySecurityRequestProto();
@@ -422,6 +398,20 @@ class LinkResolver {
     return response.getSecurityResponseList();
   }
 
+  private async batchFetchTransactions(uuids: UUID[], asOf?: LocalTimestampProto): Promise<TransactionProto[]> {
+    if (uuids.length === 0) return [];
+    const request = new QueryTransactionRequestProto();
+    request.setObjectClass('TransactionRequest');
+    request.setVersion('0.0.1');
+    const uuidProtos: UUIDProto[] = uuids.map((u) => u.toUUIDProto());
+    request.setUuidsList(uuidProtos);
+    if (asOf) request.setAsOf(asOf);
+
+    const getByIdsAsync = promisify(this.transactionClient.getByIds.bind(this.transactionClient));
+    const response = (await getByIdsAsync(request)) as QueryTransactionResponseProto;
+    return response.getTransactionResponseList();
+  }
+
   private async batchFetchPortfolios(uuids: UUID[], asOf?: LocalTimestampProto): Promise<PortfolioProto[]> {
     if (uuids.length === 0) return [];
     const request = new QueryPortfolioRequestProto();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fintekkers/ledger-models",
   "todo": "Replace the version with build script version number",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "description": "ledger model protos ",
   "authors": [
     "David Doherty",