@centrifuge/sdk 1.10.0 → 1.12.1

package/dist/entities/ShareClass.js

@@ -141,7 +141,11 @@ export class ShareClass extends Entity {
             if (res.length === 0) {
                 return of([]);
             }
-            const items = res.filter((item) => Number(item.centrifugeId) === centrifugeId || !centrifugeId);
+            const items = res.filter(
+            // Skip holdings whose asset metadata isn't indexed yet (`asset` is null):
+            // they can't be priced/rendered, and reading `asset.address` below would
+            // otherwise throw and fail the whole `balances()` stream.
+            (item) => (Number(item.centrifugeId) === centrifugeId || !centrifugeId) && item.asset != null);
             if (items.length === 0)
                 return of([]);
             return combineLatest([
@@ -391,83 +395,73 @@ export class ShareClass extends Entity {
                 self._root._protocolAddresses(self.pool.centrifugeId),
                 self.pool.metadata(),
             ]);
-            let data;
-            if (isLiability) {
-                const expenseAccount = accounts[AccountType.Expense] || metadata?.shareClasses?.[self.id.raw]?.defaultAccounts?.expense;
-                const liabilityAccount = accounts[AccountType.Liability] || metadata?.shareClasses?.[self.id.raw]?.defaultAccounts?.liability;
-                if (liabilityAccount === undefined) {
-                    throw new Error('Missing required accounts for liability creation');
-                }
-                if (expenseAccount) {
-                    data = encodeFunctionData({
-                        abi: ABI.Hub,
-                        functionName: 'initializeLiability',
-                        args: [self.pool.id.raw, self.id.raw, assetId.raw, valuation, expenseAccount, liabilityAccount],
-                    });
-                }
-                else {
-                    const newExpenseAccount = await self._getFreeAccountId();
-                    const createAccountData = encodeFunctionData({
-                        abi: ABI.Hub,
-                        functionName: 'createAccount',
-                        args: [self.pool.id.raw, newExpenseAccount, true],
-                    });
-                    const initHoldingData = encodeFunctionData({
-                        abi: ABI.Hub,
-                        functionName: 'initializeLiability',
-                        args: [self.pool.id.raw, self.id.raw, assetId.raw, valuation, newExpenseAccount, liabilityAccount],
-                    });
-                    data = [createAccountData, initHoldingData];
+            const provided = (accounts ?? {});
+            const defaults = metadata?.shareClasses?.[self.id.raw]?.defaultAccounts;
+            const createAccountCalls = [];
+            const { accounting } = await self._root._protocolAddresses(self.pool.centrifugeId);
+            const client = await firstValueFrom(self._root.getClient(self.pool.centrifugeId));
+            const allocatedIds = new Set();
+            // Resolve an account id from the explicit input or the share class defaults,
+            // otherwise allocate a fresh account with the correct normal balance. By
+            // double-entry convention asset/loss/expense are debit-normal; equity/gain/
+            // liability are credit-normal. This lets a holding be created on a pool that
+            // hasn't pre-created its accounts (instead of reverting "Missing required accounts").
+            const resolveAccount = async (explicit, fallback, isDebitNormal) => {
+                const existing = explicit ?? fallback;
+                if (existing !== undefined)
+                    return BigInt(existing);
+                // Generate a fresh id that doesn't already exist on-chain and isn't already
+                // allocated in this batch — `initializeHolding` reverts InvalidAccountCombination
+                // if any two of the four accounts collide.
+                let id = randomUint(256);
+                while (allocatedIds.has(id) ||
+                    (await client.readContract({
+                        address: accounting,
+                        abi: ABI.Accounting,
+                        functionName: 'exists',
+                        args: [self.pool.id.raw, id],
+                    }))) {
+                    id = randomUint(256);
                 }
+                allocatedIds.add(id);
+                createAccountCalls.push(encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'createAccount',
+                    args: [self.pool.id.raw, id, isDebitNormal],
+                }));
+                return id;
+            };
+            let initData;
+            if (isLiability) {
+                const expenseAccount = await resolveAccount(provided[AccountType.Expense], defaults?.expense, true);
+                const liabilityAccount = await resolveAccount(provided[AccountType.Liability], defaults?.liability, false);
+                initData = encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'initializeLiability',
+                    args: [self.pool.id.raw, self.id.raw, assetId.raw, valuation, expenseAccount, liabilityAccount],
+                });
             }
             else {
-                const assetAccount = accounts[AccountType.Asset] || metadata?.shareClasses?.[self.id.raw]?.defaultAccounts?.asset;
-                const equityAccount = accounts[AccountType.Equity] || metadata?.shareClasses?.[self.id.raw]?.defaultAccounts?.equity;
-                const gainAccount = accounts[AccountType.Gain] || metadata?.shareClasses?.[self.id.raw]?.defaultAccounts?.gain;
-                const lossAccount = accounts[AccountType.Loss] || metadata?.shareClasses?.[self.id.raw]?.defaultAccounts?.loss;
-                if (equityAccount === undefined || gainAccount === undefined || lossAccount === undefined) {
-                    throw new Error('Missing required accounts for holding creation');
-                }
-                if (assetAccount) {
-                    data = encodeFunctionData({
-                        abi: ABI.Hub,
-                        functionName: 'initializeHolding',
-                        args: [
-                            self.pool.id.raw,
-                            self.id.raw,
-                            assetId.raw,
-                            valuation,
-                            assetAccount,
-                            equityAccount,
-                            gainAccount,
-                            lossAccount,
-                        ],
-                    });
-                }
-                else {
-                    const newAssetAccount = await self._getFreeAccountId();
-                    const createAccountData = encodeFunctionData({
-                        abi: ABI.Hub,
-                        functionName: 'createAccount',
-                        args: [self.pool.id.raw, newAssetAccount, false],
-                    });
-                    const initHoldingData = encodeFunctionData({
-                        abi: ABI.Hub,
-                        functionName: 'initializeHolding',
-                        args: [
-                            self.pool.id.raw,
-                            self.id.raw,
-                            assetId.raw,
-                            valuation,
-                            newAssetAccount,
-                            equityAccount,
-                            gainAccount,
-                            lossAccount,
-                        ],
-                    });
-                    data = [createAccountData, initHoldingData];
-                }
+                const assetAccount = await resolveAccount(provided[AccountType.Asset], defaults?.asset, true);
+                const equityAccount = await resolveAccount(provided[AccountType.Equity], defaults?.equity, false);
+                const gainAccount = await resolveAccount(provided[AccountType.Gain], defaults?.gain, false);
+                const lossAccount = await resolveAccount(provided[AccountType.Loss], defaults?.loss, true);
+                initData = encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'initializeHolding',
+                    args: [
+                        self.pool.id.raw,
+                        self.id.raw,
+                        assetId.raw,
+                        valuation,
+                        assetAccount,
+                        equityAccount,
+                        gainAccount,
+                        lossAccount,
+                    ],
+                });
             }
+            const data = createAccountCalls.length > 0 ? [...createAccountCalls, initData] : initData;
             yield* wrapTransaction('Create holding', ctx, {
                 contract: hub,
                 data,
@@ -2220,19 +2214,6 @@ export class ShareClass extends Entity {
                     asset { decimals centrifugeId }
                   }
                 }
-                outstandingInvests(where: { tokenId: $scId }, limit: 1000) {
-                  items {
-                    account
-                    assetId
-                    tokenId
-                    approvedAmount
-                    approvedAt
-                    depositAmount
-                    epochIndex
-                    pendingAmount
-                    queuedAmount
-                  }
-                }
               }`, { scId: this.id.raw })
             .pipe(map((data) => {
             const maxEpochByAsset = new Map();
@@ -2289,16 +2270,45 @@ export class ShareClass extends Entity {
                         createdAtTxHash: item.createdAtTxHash ?? 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,
-                })),
+                // Derived: the deprecated `outstandingInvests` indexer field was removed
+                // (testnet). It enumerated every investor with outstanding activity —
+                // pending OR queued OR approved-but-not-yet-issued. We reconstruct that set
+                // as the union of pendingInvestOrders (pending/queued) and the open
+                // investOrders (issuedAt: null → approved-but-not-issued), keyed by
+                // (investor, assetId). pending/queued amounts come from the pending table
+                // (raw strings, '0' for approved-only investors); consumers wrap them in
+                // Balance with asset decimals and only read assetId/investor/pending/queued.
+                outstandingInvests: (() => {
+                    const byKey = new Map();
+                    data.pendingInvestOrders.items.forEach((item) => {
+                        const assetId = new AssetId(item.assetId);
+                        const account = item.account.toLowerCase();
+                        byKey.set(`${assetId.toString()}-${account}`, {
+                            assetId,
+                            account,
+                            investor: account,
+                            tokenId: this.id.raw,
+                            pendingAmount: item.pendingAssetsAmount || '0',
+                            queuedAmount: item.queuedAssetsAmount || '0',
+                        });
+                    });
+                    data.investOrders.items.forEach((item) => {
+                        const assetId = new AssetId(item.assetId);
+                        const account = item.account.toLowerCase();
+                        const key = `${assetId.toString()}-${account}`;
+                        if (!byKey.has(key)) {
+                            byKey.set(key, {
+                                assetId,
+                                account,
+                                investor: account,
+                                tokenId: this.id.raw,
+                                pendingAmount: '0',
+                                queuedAmount: '0',
+                            });
+                        }
+                    });
+                    return Array.from(byKey.values());
+                })(),
             };
         }), repeatOnEvents(this._root, {
             address: batchRequestManager,
@@ -2368,20 +2378,6 @@ export class ShareClass extends Entity {
               token { decimals }
             }
           }
-          outstandingRedeems(where: {tokenId:  $scId}, limit: 1000) {
-            items {
-              account
-              assetId
-              tokenId
-              epochIndex
-              approvedAmount
-              approvedAt
-              depositAmount
-              pendingAmount
-              queuedAmount
-              token { decimals }
-            }
-          }
         }`, { scId: this.id.raw })
             .pipe(map((data) => {
             const maxEpochByAsset = new Map();
@@ -2449,21 +2445,50 @@ export class ShareClass extends Entity {
                         revokedAt: item.revokedAt ? new Date(item.revokedAt) : null,
                     };
                 }),
-                outstandingRedeems: data.outstandingRedeems.items.map((item) => {
-                    const tokenDecimals = item.token.decimals;
-                    return {
-                        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: new Balance(item.approvedAmount, tokenDecimals),
-                        depositAmount: new Balance(item.depositAmount, tokenDecimals),
-                        pendingAmount: new Balance(item.pendingAmount, tokenDecimals),
-                        queuedAmount: new Balance(item.queuedAmount, tokenDecimals),
-                        tokenDecimals,
-                    };
-                }),
+                // Derived: the deprecated `outstandingRedeems` indexer field was removed
+                // (testnet). It enumerated every investor with outstanding activity —
+                // pending OR queued OR approved-but-not-yet-revoked. We reconstruct that set
+                // as the union of pendingRedeemOrders (pending/queued) and the open
+                // redeemOrders (revokedAt: null → approved-but-not-revoked), keyed by
+                // (investor, assetId). pending/queued amounts come from the pending table as
+                // Balance (already scaled by token decimals; zero for approved-only
+                // investors); consumers only read assetId/investor/pending/queued.
+                outstandingRedeems: (() => {
+                    const tokenDecimals = data.epochOutstandingRedeems.items[0]?.token.decimals ??
+                        data.epochRedeemOrders.items[0]?.token.decimals ??
+                        18;
+                    const byKey = new Map();
+                    data.pendingRedeemOrders.items.forEach((item) => {
+                        const assetId = new AssetId(item.assetId);
+                        const account = item.account.toLowerCase();
+                        byKey.set(`${assetId.toString()}-${account}`, {
+                            assetId,
+                            account,
+                            investor: account,
+                            tokenId: this.id.raw,
+                            pendingAmount: new Balance(item.pendingSharesAmount ?? '0', tokenDecimals),
+                            queuedAmount: new Balance(item.queuedSharesAmount ?? '0', tokenDecimals),
+                            tokenDecimals,
+                        });
+                    });
+                    data.redeemOrders.items.forEach((item) => {
+                        const assetId = new AssetId(item.assetId);
+                        const account = item.account.toLowerCase();
+                        const key = `${assetId.toString()}-${account}`;
+                        if (!byKey.has(key)) {
+                            byKey.set(key, {
+                                assetId,
+                                account,
+                                investor: account,
+                                tokenId: this.id.raw,
+                                pendingAmount: new Balance('0', tokenDecimals),
+                                queuedAmount: new Balance('0', tokenDecimals),
+                                tokenDecimals,
+                            });
+                        }
+                    });
+                    return Array.from(byKey.values());
+                })(),
             };
         }), repeatOnEvents(this._root, {
             address: batchRequestManager,