@centrifuge/sdk 1.2.0 → 1.2.1

package/dist/entities/ShareClass.js

@@ -191,37 +191,147 @@ export class ShareClass extends Entity {
      * Get the pending and approved amounts for deposits and redemptions for each asset.
      */
     pendingAmounts() {
-        return this._query(['pendingAmounts'], () => this._allVaults().pipe(map((vaults) => vaults.filter((v) => v.status === 'Linked')), switchMap((vaults) => {
-            if (vaults.length === 0)
-                return of([]);
-            return combineLatest([
-                combineLatest(vaults.map((v) => this._epoch(v.assetId))),
-                this._epochOutstandingInvests(),
-                this._epochOutstandingRedeems(),
-                this.balances(),
-            ]).pipe(map(([epochs, outInv, outRed, balancesData]) => {
-                const invByKey = new Map();
-                outInv.forEach((o) => invByKey.set(`${o.assetId.toString()}-${o.centrifugeId}`, o.amount));
-                const redByKey = new Map();
-                outRed.forEach((o) => redByKey.set(`${o.assetId.toString()}-${o.centrifugeId}`, o.amount));
-                const priceByAsset = new Map();
-                balancesData.forEach((b) => priceByAsset.set(b.assetId.toString(), b.price));
-                return epochs.map((epoch, i) => {
-                    const vault = vaults[i];
-                    const key = `${vault.assetId.toString()}-${vault.centrifugeId}`;
-                    const queuedInvest = invByKey.get(key) ?? new Balance(0n, 18);
-                    const queuedRedeem = redByKey.get(key) ?? new Balance(0n, 18);
-                    const assetPrice = priceByAsset.get(vault.assetId.toString()) ?? Price.fromFloat(1);
-                    return {
-                        assetId: vault.assetId,
-                        centrifugeId: vault.centrifugeId,
-                        queuedInvest,
-                        queuedRedeem,
-                        assetPrice,
-                        ...epoch,
-                    };
-                });
-            }));
+        return this._query(['pendingAmounts'], () => combineLatest([
+            this._allVaults().pipe(map((vaults) => vaults.filter((v) => v.status === 'Linked'))),
+            this._investOrders(),
+            this._redeemOrders(),
+            this.balances(),
+            this.pool.currency(),
+        ]).pipe(map(([vaults, investData, redeemData, balancesData, poolCurrency]) => {
+            const poolDecimals = poolCurrency.decimals;
+            if (vaults.length === 0) {
+                const zeroBalance = new Balance(0n, poolDecimals);
+                return {
+                    byVault: [],
+                    shareClassTotals: {
+                        pendingInvestments: zeroBalance,
+                        pendingRedemptions: zeroBalance,
+                        approvedInvestments: zeroBalance,
+                        approvedRedemptions: zeroBalance,
+                    },
+                };
+            }
+            const investmentsPending = new Map();
+            investData.epochOutstandingInvests.forEach((order) => {
+                investmentsPending.set(`${order.assetId.toString()}-${order.centrifugeId}`, order.pendingAmount);
+            });
+            const redemptionsPending = new Map();
+            redeemData.epochOutstandingRedeems.forEach((order) => {
+                redemptionsPending.set(`${order.assetId.toString()}-${order.centrifugeId}`, order.pendingAmount);
+            });
+            const investmentsApproved = new Map();
+            investData.epochInvestOrders.forEach((order) => {
+                const isApproved = !!order.approvedAt && !order.issuedAt;
+                const key = `${order.assetId.toString()}-${order.centrifugeId}`;
+                if (isApproved) {
+                    if (!investmentsApproved.has(key))
+                        investmentsApproved.set(key, []);
+                    investmentsApproved.get(key).push({
+                        amount: order.approvedAmount,
+                        approvedAt: order.approvedAt,
+                        epoch: order.index,
+                    });
+                }
+            });
+            const redemptionsApproved = new Map();
+            redeemData.epochRedeemOrders.forEach((order) => {
+                const isApproved = !!order.approvedAt && !order.revokedAt;
+                const key = `${order.assetId.toString()}-${order.centrifugeId}`;
+                if (isApproved) {
+                    if (!redemptionsApproved.has(key))
+                        redemptionsApproved.set(key, []);
+                    redemptionsApproved.get(key).push({
+                        amount: order.approvedAmount,
+                        approvedAt: order.approvedAt,
+                        epoch: order.index,
+                    });
+                }
+            });
+            const assetDecimals = new Map();
+            balancesData.forEach((b) => assetDecimals.set(b.assetId.toString(), b.asset.decimals));
+            const queuedInvestments = new Map();
+            investData.pendingInvestOrders.forEach((order) => {
+                const key = `${order.assetId.toString()}-${order.centrifugeId}`;
+                const decimals = assetDecimals.get(order.assetId.toString()) ?? 18;
+                const queuedAmount = new Balance(order.queuedAmount, decimals);
+                const existing = queuedInvestments.get(key);
+                if (existing) {
+                    queuedInvestments.set(key, existing.add(queuedAmount));
+                }
+                else {
+                    queuedInvestments.set(key, queuedAmount);
+                }
+            });
+            const queuedRedemptions = new Map();
+            redeemData.pendingRedeemOrders.forEach((order) => {
+                const key = `${order.assetId.toString()}-${order.centrifugeId}`;
+                const queuedAmount = new Balance(order.queuedAmount, 18); // Share tokens are always 18 decimals
+                const existing = queuedRedemptions.get(key);
+                if (existing) {
+                    queuedRedemptions.set(key, existing.add(queuedAmount));
+                }
+                else {
+                    queuedRedemptions.set(key, queuedAmount);
+                }
+            });
+            const priceByAsset = new Map();
+            balancesData.forEach((b) => priceByAsset.set(b.assetId.toString(), b.price));
+            let totalPendingInvestments = new Balance(0n, poolDecimals);
+            let totalPendingRedemptions = new Balance(0n, poolDecimals);
+            let totalApprovedInvestments = new Balance(0n, poolDecimals);
+            let totalApprovedRedemptions = new Balance(0n, poolDecimals);
+            const byVault = vaults.map((vault) => {
+                const key = `${vault.assetId.toString()}-${vault.centrifugeId}`;
+                const pendingDeposit = investmentsPending.get(key) ?? new Balance(0n, 18);
+                const pendingRedeem = redemptionsPending.get(key) ?? new Balance(0n, 18);
+                const pendingIssuances = investmentsApproved.get(key) ?? [];
+                const pendingRevocations = redemptionsApproved.get(key) ?? [];
+                const pendingIssuancesTotal = pendingIssuances.reduce((acc, curr) => acc.add(curr.amount), new Balance(0n, pendingIssuances[0]?.amount.decimals ?? 18));
+                const pendingRevocationsTotal = pendingRevocations.reduce((acc, curr) => acc.add(curr.amount), new Balance(0n, 18));
+                const queuedInvest = queuedInvestments.get(key) ?? new Balance(0n, 18);
+                const queuedRedeem = queuedRedemptions.get(key) ?? new Balance(0n, 18);
+                const assetPrice = priceByAsset.get(vault.assetId.toString()) ?? Price.fromFloat(1);
+                const pendingDepositInPoolCurrency = pendingDeposit.mul(assetPrice).scale(poolDecimals);
+                totalPendingInvestments = totalPendingInvestments.add(pendingDepositInPoolCurrency);
+                const pendingRedeemScaled = pendingRedeem.scale(poolDecimals);
+                totalPendingRedemptions = totalPendingRedemptions.add(pendingRedeemScaled);
+                const approvedInvestInPoolCurrency = pendingIssuancesTotal.mul(assetPrice).scale(poolDecimals);
+                totalApprovedInvestments = totalApprovedInvestments.add(approvedInvestInPoolCurrency);
+                const approvedRedeemScaled = pendingRevocationsTotal.scale(poolDecimals);
+                totalApprovedRedemptions = totalApprovedRedemptions.add(approvedRedeemScaled);
+                const maxInvestIndex = investData.maxEpochByAsset.get(vault.assetId.toString()) ??
+                    (pendingIssuances.length > 0 ? Math.max(...pendingIssuances.map((p) => p.epoch)) : 0);
+                const minInvestIndex = pendingIssuances.length > 0 ? Math.min(...pendingIssuances.map((p) => p.epoch)) : maxInvestIndex + 1;
+                const maxRedeemIndex = redeemData.maxEpochByAsset.get(vault.assetId.toString()) ??
+                    (pendingRevocations.length > 0 ? Math.max(...pendingRevocations.map((p) => p.epoch)) : 0);
+                const minRedeemIndex = pendingRevocations.length > 0 ? Math.min(...pendingRevocations.map((p) => p.epoch)) : maxRedeemIndex + 1;
+                return {
+                    assetId: vault.assetId,
+                    centrifugeId: vault.centrifugeId,
+                    pendingDeposit,
+                    pendingRedeem,
+                    pendingIssuances,
+                    pendingIssuancesTotal,
+                    pendingRevocations,
+                    pendingRevocationsTotal,
+                    queuedInvest,
+                    queuedRedeem,
+                    assetPrice,
+                    depositEpoch: maxInvestIndex + 1,
+                    redeemEpoch: maxRedeemIndex + 1,
+                    issueEpoch: minInvestIndex,
+                    revokeEpoch: minRedeemIndex,
+                };
+            });
+            return {
+                byVault,
+                shareClassTotals: {
+                    pendingInvestments: totalPendingInvestments,
+                    pendingRedemptions: totalPendingRedemptions,
+                    approvedInvestments: totalApprovedInvestments,
+                    approvedRedemptions: totalApprovedRedemptions,
+                },
+            };
         })));
     }
     /**
@@ -477,15 +587,16 @@ export class ShareClass extends Entity {
     approveDepositsAndIssueShares(assets) {
         const self = this;
         return this._transact(async function* (ctx) {
-            const [{ batchRequestManager }, pendingAmounts, orders] = await Promise.all([
+            const [{ batchRequestManager }, pendingAmountsData, orders] = await Promise.all([
                 self._root._protocolAddresses(self.pool.centrifugeId),
                 self.pendingAmounts(),
-                firstValueFrom(self._investorOrders().pipe(switchMap((orders) => {
-                    if (orders.outstandingInvests.length === 0)
+                firstValueFrom(self._investOrders().pipe(switchMap((investOrders) => {
+                    if (investOrders.pendingInvestOrders.length === 0)
                         return of([]);
-                    return combineLatest(orders.outstandingInvests.map((order) => self._investorOrder(order.assetId, order.investor)));
+                    return combineLatest(investOrders.pendingInvestOrders.map((order) => self._investorOrder(order.assetId, order.investor)));
                 }))),
             ]);
+            const pendingAmounts = pendingAmountsData.byVault;
             const assetsWithApprove = assets.filter((a) => 'approveAssetAmount' in a).length;
             const assetsWithIssue = assets.filter((a) => 'issuePricePerShare' in a).length;
             const gasLimitPerAsset = assetsWithIssue ? GAS_LIMIT / BigInt(assetsWithIssue) : 0n;
@@ -622,15 +733,16 @@ export class ShareClass extends Entity {
     approveRedeemsAndRevokeShares(assets) {
         const self = this;
         return this._transact(async function* (ctx) {
-            const [{ batchRequestManager }, pendingAmounts, orders] = await Promise.all([
+            const [{ batchRequestManager }, pendingAmountsData, orders] = await Promise.all([
                 self._root._protocolAddresses(self.pool.centrifugeId),
                 self.pendingAmounts(),
-                firstValueFrom(self._investorOrders().pipe(switchMap((orders) => {
-                    if (orders.outstandingRedeems.length === 0)
+                firstValueFrom(self._redeemOrders().pipe(switchMap((redeemOrders) => {
+                    if (redeemOrders.pendingRedeemOrders.length === 0)
                         return of([]);
-                    return combineLatest(orders.outstandingRedeems.map((order) => self._investorOrder(order.assetId, order.investor)));
+                    return combineLatest(redeemOrders.pendingRedeemOrders.map((order) => self._investorOrder(order.assetId, order.investor)));
                 }))),
             ]);
+            const pendingAmounts = pendingAmountsData.byVault;
             const assetsWithApprove = assets.filter((a) => 'approveShareAmount' in a).length;
             const assetsWithRevoke = assets.filter((a) => 'revokePricePerShare' in a).length;
             const gasLimitPerAsset = assetsWithRevoke ? GAS_LIMIT / BigInt(assetsWithRevoke) : 0n;
@@ -896,9 +1008,10 @@ export class ShareClass extends Entity {
             orderDirection,
         ], () => combineLatest([
             this.pool.currency(),
-            this._investorOrders(),
+            this._investOrders(),
+            this._redeemOrders(),
             this._tokenInstancePositions({ limit, offset, orderBy, orderDirection, filter }),
-        ]).pipe(switchMap(([poolCurrency, { outstandingInvests, outstandingRedeems }, { items: tokenInstancePositions, assets, pageInfo, totalCount },]) => {
+        ]).pipe(switchMap(([poolCurrency, { outstandingInvests }, { outstandingRedeems }, { items: tokenInstancePositions, assets, pageInfo, totalCount },]) => {
             // Handle empty positions case or else combineLatest([]) can hang indefinitely
             if (tokenInstancePositions.length === 0) {
                 return of({
@@ -967,7 +1080,12 @@ export class ShareClass extends Entity {
     whitelistedHolders(options) {
         const limit = options?.limit ?? 20;
         const offset = options?.offset ?? 0;
-        return this._query(['whitelistedHolders', this.id.raw, limit, offset], () => combineLatest([this.pool.currency(), this._investorOrders(), this._whitelistedInvestors({ limit, offset })]).pipe(switchMap(([poolCurrency, { outstandingInvests, outstandingRedeems }, { items: whitelistedInvestors, assets, pageInfo, totalCount },]) => {
+        return this._query(['whitelistedHolders', this.id.raw, limit, offset], () => combineLatest([
+            this.pool.currency(),
+            this._investOrders(),
+            this._redeemOrders(),
+            this._whitelistedInvestors({ limit, offset }),
+        ]).pipe(switchMap(([poolCurrency, { outstandingInvests }, { outstandingRedeems }, { items: whitelistedInvestors, assets, pageInfo, totalCount },]) => {
             if (whitelistedInvestors.length === 0) {
                 return of({
                     investors: [],
@@ -1030,9 +1148,9 @@ export class ShareClass extends Entity {
      */
     investorOrders() {
         const self = this;
-        return this._query(['investorOrders'], () => self._investorOrders().pipe(switchMap((orders) => combineLatest([
-            ...orders.outstandingInvests.map((order) => self._investorOrder(order.assetId, order.investor)),
-            ...orders.outstandingRedeems.map((order) => self._investorOrder(order.assetId, order.investor)),
+        return this._query(['investorOrders'], () => combineLatest([self._investOrders(), self._redeemOrders()]).pipe(switchMap(([investOrders, redeemOrders]) => combineLatest([
+            ...investOrders.outstandingInvests.map((order) => self._investorOrder(order.assetId, order.investor)),
+            ...redeemOrders.outstandingRedeems.map((order) => self._investorOrder(order.assetId, order.investor)),
         ]).pipe(map((investorOrders) => {
             const ordersByInvestor = new AddressMap();
             investorOrders.forEach((order) => {
@@ -1100,20 +1218,26 @@ export class ShareClass extends Entity {
      * in a given share class (per vault/chain)
      */
     investmentsByVault(centrifugeId) {
-        return this._query(['investmentsByVault', centrifugeId], () => combineLatest([this._investorOrders(), this.vaults(centrifugeId), this.pendingAmounts()]).pipe(switchMap(([orders, vaults, pendingAmounts]) => {
+        return this._query(['investmentsByVault', centrifugeId], () => combineLatest([
+            this._investOrders(),
+            this._redeemOrders(),
+            this.vaults(centrifugeId),
+            this.pendingAmounts(),
+        ]).pipe(switchMap(([investOrders, redeemOrders, vaults, pendingAmountsData]) => {
             if (!vaults.length)
                 return of([]);
+            const pendingAmounts = pendingAmountsData.byVault;
             const allInvestors = new Set();
-            orders.outstandingInvests.forEach((o) => allInvestors.add(o.investor));
-            orders.outstandingRedeems.forEach((o) => allInvestors.add(o.investor));
+            investOrders.outstandingInvests.forEach((o) => allInvestors.add(o.investor));
+            redeemOrders.outstandingRedeems.forEach((o) => allInvestors.add(o.investor));
             if (allInvestors.size === 0)
                 return of([]);
             return combineLatest(vaults.map((vault) => {
                 const vaultInvestors = new Set();
-                orders.outstandingInvests
+                investOrders.outstandingInvests
                     .filter((o) => o.assetId.equals(vault.assetId))
                     .forEach((o) => vaultInvestors.add(o.investor));
-                orders.outstandingRedeems
+                redeemOrders.outstandingRedeems
                     .filter((o) => o.assetId.equals(vault.assetId))
                     .forEach((o) => vaultInvestors.add(o.investor));
                 if (vaultInvestors.size === 0)
@@ -1321,7 +1445,6 @@ export class ShareClass extends Entity {
                         }
                         token {
                           decimals
-                          }
                         }
                       }
                     }
@@ -1507,6 +1630,131 @@ export class ShareClass extends Entity {
             return allOrders;
         })));
     }
+    /**
+     * Get detailed invest order information including per-user breakdowns with helper methods.
+     * @returns Invest order data with helper methods for efficient lookups
+     */
+    investOrdersDetails() {
+        return this._query(['investOrdersDetails'], () => combineLatest([this._investOrders(), this.balances()]).pipe(map(([investData, balancesData]) => {
+            const assetPrices = new Map();
+            const assetDecimals = new Map();
+            balancesData.forEach((b) => {
+                assetPrices.set(b.assetId.toString(), b.price);
+                assetDecimals.set(b.assetId.toString(), b.asset.decimals);
+            });
+            const pendingInvestsByVault = new Map();
+            const queuedInvestByAsset = new Map();
+            for (const order of investData.pendingInvestOrders) {
+                const assetKey = order.assetId.toString();
+                const decimals = assetDecimals.get(assetKey) ?? 18;
+                const parsedOrder = {
+                    ...order,
+                    pendingAmount: new Balance(order.pendingAmount, decimals),
+                    queuedAmount: new Balance(order.queuedAmount, decimals),
+                };
+                const vaultKey = `${order.assetId.toString()}-${order.centrifugeId}`;
+                if (!pendingInvestsByVault.has(vaultKey)) {
+                    pendingInvestsByVault.set(vaultKey, []);
+                }
+                pendingInvestsByVault.get(vaultKey).push(parsedOrder);
+                const queuedAmount = parsedOrder.queuedAmount;
+                const existing = queuedInvestByAsset.get(assetKey);
+                if (existing) {
+                    queuedInvestByAsset.set(assetKey, existing.add(queuedAmount));
+                }
+                else {
+                    queuedInvestByAsset.set(assetKey, queuedAmount);
+                }
+            }
+            const approvedInvestsByVaultAndEpoch = new Map();
+            const filteredApprovedInvests = investData.investOrders.filter((i) => !!i.approvedAt && !i.issuedAt);
+            for (const order of filteredApprovedInvests) {
+                const key = `${order.assetId.toString()}-${order.centrifugeId}-${order.index}`;
+                if (!approvedInvestsByVaultAndEpoch.has(key)) {
+                    approvedInvestsByVaultAndEpoch.set(key, []);
+                }
+                approvedInvestsByVaultAndEpoch.get(key).push(order);
+            }
+            const toAssetKey = (assetId) => typeof assetId === 'string' ? assetId : assetId.toString();
+            return {
+                getPendingInvestsByVault: (assetId, centrifugeId) => {
+                    const key = `${toAssetKey(assetId)}-${centrifugeId}`;
+                    return pendingInvestsByVault.get(key) ?? [];
+                },
+                getApprovedInvestsByVaultAndEpoch: (assetId, centrifugeId, epoch) => {
+                    const key = `${toAssetKey(assetId)}-${centrifugeId}-${epoch}`;
+                    return approvedInvestsByVaultAndEpoch.get(key) ?? [];
+                },
+                getQueuedInvestByAsset: (assetId) => {
+                    return queuedInvestByAsset.get(toAssetKey(assetId));
+                },
+                getAssetPrice: (assetId) => {
+                    return assetPrices.get(toAssetKey(assetId));
+                },
+            };
+        })));
+    }
+    /**
+     * Get detailed redeem order information including per-user breakdowns with helper methods.
+     * @returns Redeem order data with helper methods for efficient lookups
+     */
+    redeemOrdersDetails() {
+        return this._query(['redeemOrdersDetails'], () => combineLatest([this._redeemOrders(), this.balances()]).pipe(map(([redeemData, balancesData]) => {
+            const assetPrices = new Map();
+            balancesData.forEach((b) => {
+                assetPrices.set(b.assetId.toString(), b.price);
+            });
+            const pendingRedeemsByVault = new Map();
+            const queuedRedeemByAsset = new Map();
+            for (const order of redeemData.pendingRedeemOrders) {
+                const parsedOrder = {
+                    ...order,
+                    pendingAmount: new Balance(order.pendingAmount, 18),
+                    queuedAmount: new Balance(order.queuedAmount, 18),
+                };
+                const vaultKey = `${order.assetId.toString()}-${order.centrifugeId}`;
+                if (!pendingRedeemsByVault.has(vaultKey)) {
+                    pendingRedeemsByVault.set(vaultKey, []);
+                }
+                pendingRedeemsByVault.get(vaultKey).push(parsedOrder);
+                const assetKey = order.assetId.toString();
+                const queuedAmount = parsedOrder.queuedAmount;
+                const existing = queuedRedeemByAsset.get(assetKey);
+                if (existing) {
+                    queuedRedeemByAsset.set(assetKey, existing.add(queuedAmount));
+                }
+                else {
+                    queuedRedeemByAsset.set(assetKey, queuedAmount);
+                }
+            }
+            const approvedRedeemsByVaultAndEpoch = new Map();
+            const filteredApprovedRedeems = redeemData.redeemOrders.filter((i) => !!i.approvedAt && !i.revokedAt);
+            for (const order of filteredApprovedRedeems) {
+                const key = `${order.assetId.toString()}-${order.centrifugeId}-${order.index}`;
+                if (!approvedRedeemsByVaultAndEpoch.has(key)) {
+                    approvedRedeemsByVaultAndEpoch.set(key, []);
+                }
+                approvedRedeemsByVaultAndEpoch.get(key).push(order);
+            }
+            const toAssetKey = (assetId) => typeof assetId === 'string' ? assetId : assetId.toString();
+            return {
+                getPendingRedeemsByVault: (assetId, centrifugeId) => {
+                    const key = `${toAssetKey(assetId)}-${centrifugeId}`;
+                    return pendingRedeemsByVault.get(key) ?? [];
+                },
+                getApprovedRedeemsByVaultAndEpoch: (assetId, centrifugeId, epoch) => {
+                    const key = `${toAssetKey(assetId)}-${centrifugeId}-${epoch}`;
+                    return approvedRedeemsByVaultAndEpoch.get(key) ?? [];
+                },
+                getQueuedRedeemByAsset: (assetId) => {
+                    return queuedRedeemByAsset.get(toAssetKey(assetId));
+                },
+                getAssetPrice: (assetId) => {
+                    return assetPrices.get(toAssetKey(assetId));
+                },
+            };
+        })));
+    }
     /**
      * Get the valuation contract address for this share class on a specific chain.
      * @param centrifugeId
@@ -1751,43 +1999,263 @@ export class ShareClass extends Entity {
         }, centrifugeId)))));
     }
     /** @internal */
-    _investorOrders() {
-        return this._root._queryIndexer(`query ($scId: String!) {
-        pendingInvestOrders(where: {tokenId: $scId}) {
-          items {
-            account
-            assetId
-            tokenId
-            pendingAssetsAmount
-            queuedAssetsAmount
+    _investOrders() {
+        return this._query(['investOrders'], () => this._root._queryIndexer(`query ($scId: String!) {
+          epochOutstandingInvests(where: { tokenId: $scId }, limit: 1000) {
+            items {
+              assetId
+              poolId
+              tokenId
+              pendingAssetsAmount
+              asset { decimals centrifugeId }
+            }
           }
-        }
-        pendingRedeemOrders(where: {tokenId: $scId}) {
-          items {
-            account
-            assetId
-            tokenId
-            pendingSharesAmount
-            queuedSharesAmount
+          epochInvestOrders(where: { tokenId: $scId }, limit: 1000) {
+            items {
+              poolId
+              tokenId
+              assetId
+              index
+              approvedAt
+              approvedAssetsAmount
+              issuedAt
+              issuedSharesAmount
+              token { decimals }
+              asset { decimals centrifugeId }
+            }
           }
-        }
-        }`, { scId: this.id.raw }, (data) => ({
-            outstandingInvests: data.pendingInvestOrders.items.map((item) => ({
-                assetId: new AssetId(item.assetId),
-                account: item.account.toLowerCase(),
-                investor: item.account.toLowerCase(),
-                tokenId: item.tokenId.toLowerCase(),
-                pendingAmount: item.pendingAssetsAmount,
-                queuedAmount: item.queuedAssetsAmount,
-            })),
-            outstandingRedeems: data.pendingRedeemOrders.items.map((item) => ({
-                assetId: new AssetId(item.assetId),
-                account: item.account.toLowerCase(),
-                investor: item.account.toLowerCase(),
-                tokenId: item.tokenId.toLowerCase(),
-                pendingAmount: item.pendingSharesAmount,
-                queuedAmount: item.queuedSharesAmount,
-            })),
+          pendingInvestOrders(where: { tokenId: $scId }, limit: 1000) {
+            items {
+              account
+              assetId
+              tokenId
+              queuedAssetsAmount
+              pendingAssetsAmount
+            }
+          }
+          investOrders(where: { tokenId: $scId, issuedAt: null }, limit: 1000) {
+            items {
+              account
+              assetId
+              tokenId
+              index
+              approvedAt
+              approvedAssetsAmount
+              issuedAt
+              issuedSharesAmount
+              claimedAt
+              claimedSharesAmount
+              asset { decimals centrifugeId }
+            }
+          }
+          outstandingInvests(where: { tokenId: $scId }, limit: 1000) {
+            items {
+              account
+              assetId
+              tokenId
+              approvedAmount
+              approvedAt
+              depositAmount
+              epochIndex
+              pendingAmount
+              queuedAmount
+            }
+          }
+        }`, { scId: this.id.raw }, (data) => {
+            const maxEpochByAsset = new Map();
+            for (const item of data.epochInvestOrders.items) {
+                const current = maxEpochByAsset.get(item.assetId) ?? -1;
+                if (item.index > current) {
+                    maxEpochByAsset.set(item.assetId, item.index);
+                }
+            }
+            return {
+                maxEpochByAsset,
+                epochOutstandingInvests: data.epochOutstandingInvests.items.map((item) => ({
+                    assetId: new AssetId(item.assetId),
+                    centrifugeId: Number(item.asset.centrifugeId),
+                    pendingAmount: new Balance(item.pendingAssetsAmount || '0', item.asset.decimals),
+                })),
+                epochInvestOrders: data.epochInvestOrders.items.map((item) => ({
+                    assetId: new AssetId(item.assetId),
+                    centrifugeId: Number(item.asset.centrifugeId),
+                    index: item.index,
+                    approvedAt: item.approvedAt ? new Date(item.approvedAt) : null,
+                    approvedAmount: new Balance(item.approvedAssetsAmount || '0', item.asset.decimals),
+                    issuedAt: item.issuedAt,
+                    tokenDecimals: item.token.decimals,
+                    assetDecimals: item.asset.decimals,
+                })),
+                pendingInvestOrders: data.pendingInvestOrders.items.map((item) => {
+                    const assetId = new AssetId(item.assetId);
+                    return {
+                        assetId,
+                        centrifugeId: assetId.centrifugeId,
+                        account: item.account.toLowerCase(),
+                        investor: item.account.toLowerCase(),
+                        pendingAmount: item.pendingAssetsAmount || '0',
+                        queuedAmount: item.queuedAssetsAmount || '0',
+                    };
+                }),
+                investOrders: data.investOrders.items.map((item) => {
+                    const assetId = new AssetId(item.assetId);
+                    return {
+                        assetId,
+                        centrifugeId: assetId.centrifugeId,
+                        account: item.account.toLowerCase(),
+                        investor: item.account.toLowerCase(),
+                        index: item.index,
+                        approvedAt: item.approvedAt ? new Date(item.approvedAt) : null,
+                        approvedAmount: new Balance(item.approvedAssetsAmount || '0', item.asset.decimals),
+                        issuedAt: item.issuedAt ? new Date(item.issuedAt) : null,
+                    };
+                }),
+                outstandingInvests: data.outstandingInvests.items.map((item) => ({
+                    assetId: new AssetId(item.assetId),
+                    account: item.account.toLowerCase(),
+                    investor: item.account.toLowerCase(),
+                    tokenId: item.tokenId.toLowerCase(),
+                    approvedAmount: item.approvedAmount,
+                    depositAmount: item.depositAmount,
+                    pendingAmount: item.pendingAmount,
+                    queuedAmount: item.queuedAmount,
+                })),
+            };
+        }));
+    }
+    /** @internal */
+    _redeemOrders() {
+        return this._query(['redeemOrders'], () => this._root._queryIndexer(`query ($scId: String!) {
+          epochOutstandingRedeems(where: { tokenId: $scId }, limit: 1000) {
+            items {
+              assetId
+              poolId
+              tokenId
+              pendingSharesAmount
+              asset { decimals centrifugeId }
+            }
+          }
+          epochRedeemOrders(where: { tokenId: $scId }, limit: 1000) {
+            items {
+              poolId
+              tokenId
+              assetId
+              index
+              approvedAt
+              approvedSharesAmount
+              revokedAt
+              revokedSharesAmount
+              revokedAssetsAmount
+              token { decimals }
+              asset { decimals centrifugeId }
+            }
+          }
+          pendingRedeemOrders(where: { tokenId: $scId }, limit: 1000) {
+            items {
+              account
+              assetId
+              tokenId
+              queuedSharesAmount
+              pendingSharesAmount
+            }
+          }
+          redeemOrders(where: { tokenId: $scId, revokedAt: null }, limit: 1000) {
+            items {
+              account
+              assetId
+              tokenId
+              index
+              approvedAt
+              approvedSharesAmount
+              revokedAt
+              revokedSharesAmount
+              revokedAssetsAmount
+              claimedAt
+              claimedAssetsAmount
+              asset { decimals centrifugeId }
+              token { decimals }
+            }
+          }
+          outstandingRedeems(where: {tokenId:  $scId}, limit: 1000) {
+            items {
+              account
+              assetId
+              tokenId
+              epochIndex
+              approvedAmount
+              approvedAt
+              depositAmount
+              pendingAmount
+              queuedAmount
+            }
+          }
+        }`, { scId: this.id.raw }, (data) => {
+            const maxEpochByAsset = new Map();
+            for (const item of data.epochRedeemOrders.items) {
+                const current = maxEpochByAsset.get(item.assetId) ?? -1;
+                if (item.index > current) {
+                    maxEpochByAsset.set(item.assetId, item.index);
+                }
+            }
+            return {
+                maxEpochByAsset,
+                epochOutstandingRedeems: data.epochOutstandingRedeems.items.map((item) => {
+                    const assetId = new AssetId(item.assetId);
+                    return {
+                        assetId,
+                        centrifugeId: assetId.centrifugeId,
+                        pendingAmount: new Balance(item.pendingSharesAmount || '0', 18),
+                    };
+                }),
+                epochRedeemOrders: data.epochRedeemOrders.items.map((item) => {
+                    const assetId = new AssetId(item.assetId);
+                    return {
+                        assetId,
+                        centrifugeId: assetId.centrifugeId,
+                        index: item.index,
+                        approvedAt: item.approvedAt ? new Date(item.approvedAt) : null,
+                        revokedAt: item.revokedAt ? new Date(item.revokedAt) : null,
+                        approvedAmount: new Balance(item.approvedSharesAmount || '0', 18),
+                        tokenDecimals: item.token.decimals,
+                        assetDecimals: item.asset.decimals,
+                    };
+                }),
+                pendingRedeemOrders: data.pendingRedeemOrders.items.map((item) => {
+                    const assetId = new AssetId(item.assetId);
+                    return {
+                        assetId,
+                        centrifugeId: assetId.centrifugeId,
+                        account: item.account.toLowerCase(),
+                        investor: item.account.toLowerCase(),
+                        pendingAmount: item.pendingSharesAmount || '0',
+                        queuedAmount: item.queuedSharesAmount || '0',
+                    };
+                }),
+                redeemOrders: data.redeemOrders.items.map((item) => {
+                    const assetId = new AssetId(item.assetId);
+                    return {
+                        assetId,
+                        centrifugeId: assetId.centrifugeId,
+                        account: item.account.toLowerCase(),
+                        investor: item.account.toLowerCase(),
+                        index: item.index,
+                        approvedAt: item.approvedAt ? new Date(item.approvedAt) : null,
+                        approvedAmount: new Balance(item.approvedSharesAmount || '0', 18),
+                        revokedAt: item.revokedAt ? new Date(item.revokedAt) : null,
+                    };
+                }),
+                outstandingRedeems: data.outstandingRedeems.items.map((item) => ({
+                    assetId: new AssetId(item.assetId),
+                    account: item.account.toLowerCase(),
+                    investor: item.account.toLowerCase(),
+                    tokenId: item.tokenId.toLowerCase(),
+                    approvedAt: item.approvedAt ? new Date(item.approvedAt) : null,
+                    approvedAmount: item.approvedAmount,
+                    depositAmount: item.depositAmount,
+                    pendingAmount: item.pendingAmount,
+                    queuedAmount: item.queuedAmount,
+                })),
+            };
         }));
     }
     /** @internal */
@@ -1928,127 +2396,6 @@ export class ShareClass extends Entity {
         }, this.pool.centrifugeId)))));
     }
     /** @internal */
-    _epochInvestOrders() {
-        return this._query(['epochInvestOrders'], () => this._root._queryIndexer(`query ($scId: String!) {
-          epochInvestOrders(where: {tokenId: $scId, issuedAt: null, approvedAt_not: null}, limit: 1000) {
-            items {
-              approvedAt
-              assetId
-              index
-            }
-          }
-        }`, { scId: this.id.raw }, (data) => {
-            const ordersMap = new Map();
-            data.epochInvestOrders.items.forEach((item) => {
-                const key = item.assetId.toString();
-                if (!ordersMap.has(key)) {
-                    ordersMap.set(key, []);
-                }
-                ordersMap.get(key)[item.index] = {
-                    approvedAt: item.approvedAt,
-                    assetId: item.assetId,
-                    index: item.index,
-                };
-            });
-            return ordersMap;
-        }));
-    }
-    /** @internal */
-    _epochRedeemOrders() {
-        return this._query(['epochRedeemOrders'], () => this._root._queryIndexer(`query ($scId: String!) {
-          epochRedeemOrders(where: {tokenId: $scId, revokedAt: null, approvedAt_not: null}, limit: 1000) {
-            items {
-              approvedAt
-              assetId
-              index
-            }
-          }
-        }`, { scId: this.id.raw }, (data) => {
-            const ordersMap = new Map();
-            data.epochRedeemOrders.items.forEach((item) => {
-                const key = item.assetId.toString();
-                if (!ordersMap.has(key)) {
-                    ordersMap.set(key, []);
-                }
-                ordersMap.get(key)[item.index] = {
-                    approvedAt: item.approvedAt,
-                    assetId: item.assetId,
-                    index: item.index,
-                };
-            });
-            return ordersMap;
-        }));
-    }
-    /** @internal */
-    _epoch(assetId) {
-        return this._query(['epoch', assetId.toString()], () => combineLatest([
-            this._root._protocolAddresses(this.pool.centrifugeId),
-            this.pool.currency(),
-            this._root._assetDecimals(assetId, this.pool.centrifugeId),
-            this._epochInvestOrders(),
-            this._epochRedeemOrders(),
-            this._root.getClient(this.pool.centrifugeId),
-        ]).pipe(switchMap(([{ batchRequestManager }, poolCurrency, assetDecimals, epochInvestOrders, epochRedeemOrders, client]) => defer(async () => {
-            const scm = getContract({
-                address: batchRequestManager,
-                abi: ABI.BatchRequestManager,
-                client,
-            });
-            const [epoch, pendingDeposit, pendingRedeem] = await Promise.all([
-                scm.read.epochId([this.pool.id.raw, this.id.raw, assetId.raw]),
-                scm.read.pendingDeposit([this.pool.id.raw, this.id.raw, assetId.raw]),
-                scm.read.pendingRedeem([this.pool.id.raw, this.id.raw, assetId.raw]),
-            ]);
-            const depositEpoch = epoch[0] + 1;
-            const redeemEpoch = epoch[1] + 1;
-            const issueEpoch = epoch[2] + 1;
-            const revokeEpoch = epoch[3] + 1;
-            const [depositEpochAmounts, redeemEpochAmount] = await Promise.all([
-                Promise.all(Array.from({ length: depositEpoch - issueEpoch }).map((_, i) => scm.read.epochInvestAmounts([this.pool.id.raw, this.id.raw, assetId.raw, issueEpoch + i]))),
-                Promise.all(Array.from({ length: redeemEpoch - revokeEpoch }).map((_, i) => scm.read.epochRedeemAmounts([this.pool.id.raw, this.id.raw, assetId.raw, revokeEpoch + i]))),
-            ]);
-            const approvedDeposit = depositEpochAmounts.reduce((acc, amount) => acc + amount[1], 0n);
-            const approvedRedeem = redeemEpochAmount.reduce((acc, amount) => acc + amount[1], 0n);
-            return {
-                depositEpoch,
-                redeemEpoch,
-                issueEpoch,
-                revokeEpoch,
-                pendingDeposit: new Balance(pendingDeposit, assetDecimals),
-                pendingRedeem: new Balance(pendingRedeem, poolCurrency.decimals),
-                pendingIssuancesTotal: new Balance(approvedDeposit, assetDecimals),
-                pendingIssuances: depositEpochAmounts.map(([, amount], i) => ({
-                    amount: new Balance(amount, assetDecimals),
-                    approvedAt: epochInvestOrders.get(assetId.toString())?.[issueEpoch + i]?.approvedAt,
-                    epoch: issueEpoch + i,
-                })),
-                pendingRevocationsTotal: new Balance(approvedRedeem, poolCurrency.decimals),
-                pendingRevocations: redeemEpochAmount.map(([, amount], i) => ({
-                    amount: new Balance(amount, poolCurrency.decimals),
-                    approvedAt: epochRedeemOrders.get(assetId.toString())?.[revokeEpoch + i]?.approvedAt,
-                    epoch: revokeEpoch + i,
-                })),
-            };
-        }).pipe(repeatOnEvents(this._root, {
-            address: batchRequestManager,
-            eventName: [
-                'ApproveDeposits',
-                'ApproveRedeems',
-                'IssueShares',
-                'RevokeShares',
-                'RemoteIssueShares',
-                'RemoteRevokeShares',
-                'UpdateDepositRequest',
-                'UpdateRedeemRequest',
-            ],
-            filter: (events) => {
-                return events.some((event) => {
-                    return event.args.scId === this.id.raw;
-                });
-            },
-        }, this.pool.centrifugeId)))));
-    }
-    /** @internal */
     _updateContract(centrifugeId, target, payload) {
         const self = this;
         return this._transact(async function* (ctx) {
@@ -2073,42 +2420,6 @@ export class ShareClass extends Entity {
         }, this.pool.centrifugeId);
     }
     /** @internal */
-    _epochOutstandingInvests() {
-        return this._query(['epochOutstandingInvests'], () => this._root._queryIndexer(`query ($scId: String!) {
-            epochOutstandingInvests(where: { tokenId: $scId }, limit: 1000) {
-              items {
-                assetId
-                pendingAssetsAmount
-                asset { decimals centrifugeId }
-              }
-            }
-          }`, { scId: this.id.raw }, (data) => {
-            return data.epochOutstandingInvests.items.map((item) => ({
-                assetId: new AssetId(item.assetId),
-                centrifugeId: item.asset.centrifugeId,
-                amount: new Balance(item.pendingAssetsAmount || 0, item.asset.decimals),
-            }));
-        }));
-    }
-    /** @internal */
-    _epochOutstandingRedeems() {
-        return this._query(['epochOutstandingRedeems'], () => this._root._queryIndexer(`query ($scId: String!) {
-            epochOutstandingRedeems(where: { tokenId: $scId }, limit: 1000) {
-              items {
-                assetId
-                pendingSharesAmount
-                asset { decimals centrifugeId }
-              }
-            }
-          }`, { scId: this.id.raw }, (data) => {
-            return data.epochOutstandingRedeems.items.map((item) => ({
-                assetId: new AssetId(item.assetId),
-                centrifugeId: item.asset.centrifugeId,
-                amount: new Balance(item.pendingSharesAmount || 0, 18),
-            }));
-        }));
-    }
-    /** @internal */
     _share(centrifugeId) {
         return this._query(['share', centrifugeId], () => this.pool.network(centrifugeId).pipe(switchMap((network) => network._share(this.id))));
     }