@centrifuge/sdk 1.10.0 → 1.12.0

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,