@centrifuge/sdk 0.0.0-alpha.28 → 0.0.0-alpha.30

package/dist/entities/ShareClass.js

@@ -2,14 +2,16 @@ import { catchError, combineLatest, defer, EMPTY, expand, filter, map, of, switc
 import { encodeFunctionData, encodePacked, getContract, parseAbi } from 'viem';
 import { ABI } from '../abi/index.js';
 import { AccountType } from '../types/holdings.js';
+import { MessageType } from '../types/transaction.js';
 import { Balance, Price } from '../utils/BigInt.js';
 import { addressToBytes32, randomUint } from '../utils/index.js';
 import { repeatOnEvents } from '../utils/rx.js';
-import { doTransaction } from '../utils/transaction.js';
+import { wrapTransaction } from '../utils/transaction.js';
 import { AssetId, ShareClassId } from '../utils/types.js';
 import { BalanceSheet } from './BalanceSheet.js';
 import { Entity } from './Entity.js';
 import { PoolNetwork } from './PoolNetwork.js';
+import { Vault } from './Vault.js';
 /**
  * Query and interact with a share class, which allows querying total issuance, NAV per share,
  * and allows interactions related to asynchronous deposits and redemptions.
@@ -29,9 +31,8 @@ export class ShareClass extends Entity {
      * @returns The details of the share class, including name, symbol, total issuance, and NAV per share.
      */
     details() {
-        return this._query(null, () => combineLatest([this._metrics(), this._metadata(), this.navPerNetwork()]).pipe(map(([metrics, metadata, navPerNetwork]) => {
-            const totalIssuance = navPerNetwork.reduce((acc, item) => acc.add(item.totalIssuance), new Balance(0n, 18) // TODO: Replace with pool currency decimals
-            );
+        return this._query(null, () => combineLatest([this._metrics(), this._metadata(), this.navPerNetwork(), this.pool.currency()]).pipe(map(([metrics, metadata, navPerNetwork, poolCurrency]) => {
+            const totalIssuance = navPerNetwork.reduce((acc, item) => acc.add(item.totalIssuance), new Balance(0n, poolCurrency.decimals));
             return {
                 id: this.id,
                 name: metadata.name,
@@ -53,113 +54,88 @@ export class ShareClass extends Entity {
         })));
     }
     navPerNetwork() {
-        return this._root._queryIndexer(`query ($scId: String!) {
-        tokenInstances(where: { tokenId: $scId }) {
-          items {
-            totalIssuance
-            tokenPrice
-            blockchain {
-              id
-            }
-          }
-        }
-      }`, { scId: this.id.raw }, (data) => data.tokenInstances.items.map((item) => ({
+        return this._query(null, () => this.pool.currency().pipe(switchMap((poolCurrency) => this._root._queryIndexer(`query ($scId: String!) {
+              tokenInstances(where: { tokenId: $scId }) {
+                items {
+                  totalIssuance
+                  tokenPrice
+                  blockchain {
+                    id
+                  }
+                }
+              }
+            }`, { scId: this.id.raw }, (data) => data.tokenInstances.items.map((item) => ({
             chainId: Number(item.blockchain.id),
-            totalIssuance: new Balance(item.totalIssuance, 18), // TODO: Replace with pool currency decimals
+            totalIssuance: new Balance(item.totalIssuance, poolCurrency.decimals),
             pricePerShare: new Price(item.tokenPrice),
-            nav: new Balance(item.totalIssuance, 18).mul(new Price(item.tokenPrice)),
-        })));
+            nav: new Balance(item.totalIssuance, poolCurrency.decimals).mul(new Price(item.tokenPrice)),
+        }))))));
     }
     /**
      * Query the vaults of the share class.
-     * @param chainId The chain ID to query the vaults on.
-     * @returns The vaults of the share class on the given chain.
+     * @param chainId The optional chain ID to query the vaults on.
+     * @returns All vaults of the share class, or filtered by the given chain.
      */
     vaults(chainId) {
-        return this._query(null, () => new PoolNetwork(this._root, this.pool, chainId).vaults(this.id));
+        return this._query(null, () => this._allVaults().pipe(map((allVaults) => {
+            const vaults = allVaults.filter((vault) => vault.chainId === chainId || !chainId);
+            return vaults.map((vault) => new Vault(this._root, new PoolNetwork(this._root, this.pool, vault.chainId), this, vault.assetAddress, vault.address));
+        })));
     }
     /**
-     * Query all the holdings of the share class.
+     * Query all the balances of the share class (from BalanceSheet and Holdings).
      */
-    holdings() {
-        return this._query(null, () => this._holdings().pipe(switchMap((res) => {
-            if (res.holdings.items.length === 0) {
+    balances(chainId) {
+        return this._query(null, () => combineLatest([this._balances(), this.pool.currency()]).pipe(switchMap(([res, poolCurrency]) => {
+            if (res.length === 0) {
                 return of([]);
             }
-            return combineLatest(res.holdings.items.map((holding) => {
-                const assetId = new AssetId(holding.assetId);
-                return this._holding(assetId);
-            })).pipe(map((holdings) => holdings.map(({ assetDecimals: _, ...holding }, i) => {
-                const data = res.holdings.items[i];
+            const items = res.filter((item) => Number(item.asset.blockchain.id) === chainId || !chainId);
+            return combineLatest([
+                combineLatest(items.map((holding) => {
+                    if (!holding.holding)
+                        return of(null);
+                    const assetId = new AssetId(holding.assetId);
+                    return this._holding(assetId);
+                })),
+                combineLatest(items.map((holding) => {
+                    const assetId = new AssetId(holding.assetId);
+                    return this._balance(Number(holding.asset.blockchain.id), {
+                        address: holding.asset.address,
+                        assetTokenId: BigInt(holding.asset.assetTokenId),
+                        id: assetId,
+                        decimals: holding.asset.decimals,
+                    });
+                })),
+            ]).pipe(map(([holdings, balances]) => items.map((data, i) => {
+                const holding = holdings[i];
+                const balance = balances[i];
+                // If the holding hasn't been initialized yet, the price is 1
+                const price = holding ? balance.price : Price.fromFloat(1);
+                const value = Balance.fromFloat(balance.amount.toDecimal().mul(price.toDecimal()), poolCurrency.decimals);
                 return {
-                    ...holding,
+                    assetId: new AssetId(data.assetId),
+                    amount: balance.amount,
+                    value,
+                    price,
                     asset: {
-                        decimals: data.holdingEscrow.asset.decimals,
-                        address: data.holdingEscrow.asset.address,
-                        name: data.holdingEscrow.asset.name,
-                        symbol: data.holdingEscrow.asset.symbol,
-                        chainId: Number(data.holdingEscrow.asset.blockchain.id),
+                        decimals: data.asset.decimals,
+                        address: data.asset.address,
+                        name: data.asset.name,
+                        symbol: data.asset.symbol,
+                        chainId: Number(data.asset.blockchain.id),
+                    },
+                    holding: holding && {
+                        valuation: holding.valuation,
+                        amount: holding.amount,
+                        value: holding.value,
+                        isLiability: holding.isLiability,
+                        accounts: holding.accounts,
                     },
                 };
             })));
         })));
     }
-    /** @internal */
-    _holding(assetId) {
-        return this._query(['holding', assetId.toString()], () => this._root._protocolAddresses(this.pool.chainId).pipe(switchMap(({ holdings: holdingsAddr, hubRegistry }) => defer(async () => {
-            const holdings = getContract({
-                address: holdingsAddr,
-                abi: ABI.Holdings,
-                client: this._root.getClient(this.pool.chainId),
-            });
-            const [valuation, amount, value, assetDecimals, isLiability, ...accounts] = await Promise.all([
-                holdings.read.valuation([this.pool.id.raw, this.id.raw, assetId.raw]),
-                holdings.read.amount([this.pool.id.raw, this.id.raw, assetId.raw]),
-                holdings.read.value([this.pool.id.raw, this.id.raw, assetId.raw]),
-                this._root.getClient(this.pool.chainId).readContract({
-                    address: hubRegistry,
-                    // Use inline ABI because of function overload
-                    abi: parseAbi(['function decimals(uint256) view returns (uint8)']),
-                    functionName: 'decimals',
-                    args: [assetId.raw],
-                }),
-                holdings.read.isLiability([this.pool.id.raw, this.id.raw, assetId.raw]),
-                ...[
-                    AccountType.Asset,
-                    AccountType.Equity,
-                    AccountType.Loss,
-                    AccountType.Gain,
-                    AccountType.Expense,
-                    AccountType.Liability,
-                ].map((kind) => holdings.read.accountId([this.pool.id.raw, this.id.raw, assetId.raw, kind])),
-            ]);
-            return {
-                assetId,
-                assetDecimals,
-                valuation,
-                amount: new Balance(amount, assetDecimals),
-                value: new Balance(value, 18), // TODO: Replace with pool currency decimals
-                isLiability,
-                accounts: {
-                    [AccountType.Asset]: accounts[0] || null,
-                    [AccountType.Equity]: accounts[1] || null,
-                    [AccountType.Loss]: accounts[2] || null,
-                    [AccountType.Gain]: accounts[3] || null,
-                    [AccountType.Expense]: accounts[4] || null,
-                    [AccountType.Liability]: accounts[5] || null,
-                },
-            };
-        }).pipe(repeatOnEvents(this._root, {
-            address: holdingsAddr,
-            abi: ABI.Holdings,
-            eventName: ['Increase', 'Decrease', 'Update', 'UpdateValuation'],
-            filter: (events) => {
-                return events.some((event) => {
-                    return event.args.scId === this.id && event.args.assetId === assetId.raw;
-                });
-            },
-        }, this.pool.chainId)))));
-    }
     /**
      * Get the pending and approved amounts for deposits and redemptions for each asset.
      */
@@ -253,12 +229,12 @@ export class ShareClass extends Entity {
      */
     createHolding(assetId, valuation, isLiability, accounts) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
+        return this._transact(async function* (ctx) {
             const [{ hub }, metadata] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self.pool.metadata(),
             ]);
-            let tx;
+            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;
@@ -266,8 +242,7 @@ export class ShareClass extends Entity {
                     throw new Error('Missing required accounts for liability creation');
                 }
                 if (expenseAccount) {
-                    tx = walletClient.writeContract({
-                        address: hub,
+                    data = encodeFunctionData({
                         abi: ABI.Hub,
                         functionName: 'initializeLiability',
                         args: [self.pool.id.raw, self.id.raw, assetId.raw, valuation, expenseAccount, liabilityAccount],
@@ -285,12 +260,7 @@ export class ShareClass extends Entity {
                         functionName: 'initializeLiability',
                         args: [self.pool.id.raw, self.id.raw, assetId.raw, valuation, newExpenseAccount, liabilityAccount],
                     });
-                    tx = walletClient.writeContract({
-                        address: hub,
-                        abi: ABI.Hub,
-                        functionName: 'multicall',
-                        args: [[createAccountData, initHoldingData]],
-                    });
+                    data = [createAccountData, initHoldingData];
                 }
             }
             else {
@@ -302,8 +272,7 @@ export class ShareClass extends Entity {
                     throw new Error('Missing required accounts for holding creation');
                 }
                 if (assetAccount) {
-                    tx = walletClient.writeContract({
-                        address: hub,
+                    data = encodeFunctionData({
                         abi: ABI.Hub,
                         functionName: 'initializeHolding',
                         args: [
@@ -339,81 +308,101 @@ export class ShareClass extends Entity {
                             lossAccount,
                         ],
                     });
-                    tx = walletClient.writeContract({
-                        address: hub,
-                        abi: ABI.Hub,
-                        functionName: 'multicall',
-                        args: [[createAccountData, initHoldingData]],
-                    });
+                    data = [createAccountData, initHoldingData];
                 }
             }
-            yield* doTransaction('Create holding', publicClient, () => tx);
+            yield* wrapTransaction('Create holding', ctx, {
+                contract: hub,
+                data,
+            });
         }, this.pool.chainId);
     }
     updateSharePrice(pricePerShare) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
+        return this._transact(async function* (ctx) {
             const { hub } = await self._root._protocolAddresses(self.pool.chainId);
-            yield* doTransaction('Update price', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'updateSharePrice',
-                args: [self.pool.id.raw, self.id.raw, pricePerShare.toBigInt()],
-            }));
+            yield* wrapTransaction('Update share price', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'updateSharePrice',
+                    args: [self.pool.id.raw, self.id.raw, pricePerShare.toBigInt()],
+                }),
+            });
         }, this.pool.chainId);
     }
     setMaxAssetPriceAge(assetId, maxPriceAge) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
+        return this._transact(async function* (ctx) {
             const { hub } = await self._root._protocolAddresses(self.pool.chainId);
-            yield* doTransaction('Set max asset price age', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'setMaxAssetPriceAge',
-                args: [self.pool.id.raw, self.id.raw, assetId.raw, BigInt(maxPriceAge)],
-            }));
+            yield* wrapTransaction('Set max asset price age', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'setMaxAssetPriceAge',
+                    args: [self.pool.id.raw, self.id.raw, assetId.raw, BigInt(maxPriceAge)],
+                }),
+                messages: {
+                    [assetId.centrifugeId]: [MessageType.MaxAssetPriceAge],
+                },
+            });
         }, this.pool.chainId);
     }
     setMaxSharePriceAge(chainId, maxPriceAge) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
+        return this._transact(async function* (ctx) {
             const [{ hub }, id] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self._root.id(chainId),
             ]);
-            yield* doTransaction('Set max share price age', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'setMaxSharePriceAge',
-                args: [id, self.pool.id.raw, self.id.raw, BigInt(maxPriceAge)],
-            }));
+            yield* wrapTransaction('Set max share price age', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'setMaxSharePriceAge',
+                    args: [id, self.pool.id.raw, self.id.raw, BigInt(maxPriceAge)],
+                }),
+                messages: {
+                    [id]: [MessageType.MaxSharePriceAge],
+                },
+            });
         }, this.pool.chainId);
     }
     notifyAssetPrice(assetId) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
+        return this._transact(async function* (ctx) {
             const { hub } = await self._root._protocolAddresses(self.pool.chainId);
-            yield* doTransaction('Notify asset price', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'notifyAssetPrice',
-                args: [self.pool.id.raw, self.id.raw, assetId.raw],
-            }));
+            yield* wrapTransaction('Notify asset price', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'notifyAssetPrice',
+                    args: [self.pool.id.raw, self.id.raw, assetId.raw],
+                }),
+                messages: {
+                    [assetId.centrifugeId]: [MessageType.NotifyPricePoolPerAsset],
+                },
+            });
         }, this.pool.chainId);
     }
     notifySharePrice(chainId) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
+        return this._transact(async function* (ctx) {
             const [{ hub }, id] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self._root.id(chainId),
             ]);
-            yield* doTransaction('Notify share price', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'notifySharePrice',
-                args: [self.pool.id.raw, self.id.raw, id],
-            }));
+            yield* wrapTransaction('Notify share price', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'notifySharePrice',
+                    args: [self.pool.id.raw, self.id.raw, id],
+                }),
+                messages: {
+                    [id]: [MessageType.NotifyPricePoolPerShare],
+                },
+            });
         }, this.pool.chainId);
     }
     /**
@@ -423,18 +412,17 @@ export class ShareClass extends Entity {
     approveDepositsAndIssueShares(assets) {
         // TODO: Also claim orders
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
-            const centIds = [...new Set(assets.map((a) => a.assetId.centrifugeId))];
-            const [{ hub }, pendingAmounts,
-            // ...estimates
-            ] = await Promise.all([
+        return this._transact(async function* (ctx) {
+            const [{ hub }, pendingAmounts] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self.pendingAmounts(),
-                ...centIds.map((centId) => self._root._estimate(self.pool.chainId, { centId })),
             ]);
-            // const estimateByCentId: Map<number, bigint> = new Map(centIds.map((centId, i) => [centId, estimates[i]!]))
             const batch = [];
-            const estimate = 0n;
+            const messages = {};
+            // function addMessage(centId: number, message: MessageType) {
+            //   if (!messages[centId]) messages[centId] = []
+            //   messages[centId].push(message)
+            // }
             for (const asset of assets) {
                 const pending = pendingAmounts.find((e) => e.assetId.equals(asset.assetId));
                 if (!pending) {
@@ -481,21 +469,10 @@ export class ShareClass extends Entity {
             if (batch.length === 0) {
                 throw new Error('No approve or issue actions provided');
             }
-            yield* doTransaction('Approve and issue', publicClient, () => {
-                if (batch.length === 1) {
-                    return walletClient.sendTransaction({
-                        data: batch[0],
-                        to: hub,
-                        value: estimate,
-                    });
-                }
-                return walletClient.writeContract({
-                    address: hub,
-                    abi: ABI.Hub,
-                    functionName: 'multicall',
-                    args: [batch],
-                    value: estimate,
-                });
+            yield* wrapTransaction('Approve and issue', ctx, {
+                contract: hub,
+                data: batch,
+                messages,
             });
         }, this.pool.chainId);
     }
@@ -506,18 +483,17 @@ export class ShareClass extends Entity {
     approveRedeemsAndRevokeShares(assets) {
         // TODO: Also claim orders
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
-            const centIds = [...new Set(assets.map((a) => a.assetId.centrifugeId))];
-            const [{ hub }, pendingAmounts,
-            // ...estimates
-            ] = await Promise.all([
+        return this._transact(async function* (ctx) {
+            const [{ hub }, pendingAmounts] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self.pendingAmounts(),
-                ...centIds.map((centId) => self._root._estimate(self.pool.chainId, { centId })),
             ]);
-            // const estimateByCentId: Map<number, bigint> = new Map(centIds.map((centId, i) => [centId, estimates[i]!]))
             const batch = [];
-            const estimate = 0n;
+            const messages = {};
+            // function addMessage(centId: number, message: MessageType) {
+            //   if (!messages[centId]) messages[centId] = []
+            //   messages[centId].push(message)
+            // }
             for (const asset of assets) {
                 const pending = pendingAmounts.find((e) => e.assetId.equals(asset.assetId));
                 if (!pending) {
@@ -569,21 +545,10 @@ export class ShareClass extends Entity {
             if (batch.length === 0) {
                 throw new Error('No approve or revoke actions provided');
             }
-            yield* doTransaction('Approve and revoke', publicClient, () => {
-                if (batch.length === 1) {
-                    return walletClient.sendTransaction({
-                        data: batch[0],
-                        to: hub,
-                        value: estimate,
-                    });
-                }
-                return walletClient.writeContract({
-                    address: hub,
-                    abi: ABI.Hub,
-                    functionName: 'multicall',
-                    args: [batch],
-                    value: estimate,
-                });
+            yield* wrapTransaction('Approve and revoke', ctx, {
+                contract: hub,
+                data: batch,
+                messages,
             });
         }, this.pool.chainId);
     }
@@ -593,25 +558,26 @@ export class ShareClass extends Entity {
      */
     claimDeposit(assetId, investor) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
-            const [{ hub }, investorOrder, estimate] = await Promise.all([
+        return this._transact(async function* (ctx) {
+            const [{ hub }, investorOrder] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self.investorOrder(assetId, investor),
-                self._root._estimate(self.pool.chainId, { centId: assetId.centrifugeId }),
             ]);
-            yield* doTransaction('Claim deposit', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'notifyDeposit',
-                args: [
-                    self.pool.id.raw,
-                    self.id.raw,
-                    assetId.raw,
-                    addressToBytes32(investor),
-                    investorOrder.maxDepositClaims,
-                ],
-                value: estimate,
-            }));
+            yield* wrapTransaction('Claim deposit', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'notifyDeposit',
+                    args: [
+                        self.pool.id.raw,
+                        self.id.raw,
+                        assetId.raw,
+                        addressToBytes32(investor),
+                        investorOrder.maxDepositClaims,
+                    ],
+                }),
+                messages: { [assetId.centrifugeId]: [MessageType.RequestCallback] },
+            });
         }, this.pool.chainId);
     }
     /**
@@ -620,19 +586,20 @@ export class ShareClass extends Entity {
      */
     claimRedeem(assetId, investor) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
-            const [{ hub }, investorOrder, estimate] = await Promise.all([
+        return this._transact(async function* (ctx) {
+            const [{ hub }, investorOrder] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self.investorOrder(assetId, investor),
-                self._root._estimate(self.pool.chainId, { centId: assetId.centrifugeId }),
             ]);
-            yield* doTransaction('Claim redeem', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'notifyRedeem',
-                args: [self.pool.id.raw, self.id.raw, assetId.raw, addressToBytes32(investor), investorOrder.maxRedeemClaims],
-                value: estimate,
-            }));
+            yield* wrapTransaction('Claim redeem', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'notifyRedeem',
+                    args: [self.pool.id.raw, self.id.raw, assetId.raw, addressToBytes32(investor), investorOrder.maxRedeemClaims],
+                }),
+                messages: { [assetId.centrifugeId]: [MessageType.RequestCallback] },
+            });
         }, this.pool.chainId);
     }
     /**
@@ -643,45 +610,146 @@ export class ShareClass extends Entity {
      */
     updateMember(address, validUntil, chainId) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
-            const [{ hub }, id, estimate] = await Promise.all([
+        return this._transact(async function* (ctx) {
+            const [{ hub }, id] = await Promise.all([
                 self._root._protocolAddresses(self.pool.chainId),
                 self._root.id(chainId),
-                self._root._estimate(self.pool.chainId, { chainId }),
             ]);
             const payload = encodePacked(['uint8', 'bytes32', 'uint64'], [/* UpdateRestrictionType.Member */ 1, addressToBytes32(address), BigInt(validUntil)]);
-            yield* doTransaction('Update restriction', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'updateRestriction',
-                args: [self.pool.id.raw, self.id.raw, id, payload, 0n],
-                value: estimate,
-            }));
+            yield* wrapTransaction('Update member', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'updateRestriction',
+                    args: [self.pool.id.raw, self.id.raw, id, payload, 0n],
+                }),
+                messages: { [id]: [MessageType.UpdateRestriction] },
+            });
         }, this.pool.chainId);
     }
     /** @internal */
-    _holdings() {
+    _balances() {
         return this._root._queryIndexer(`query ($scId: String!) {
-        holdings(where: { tokenId: $scId }) {
+        holdingEscrows(where: { tokenId: $scId }) {
           items {
+            holding {
+              updatedAt
+            }
+            assetAmount
+            assetPrice
             assetId
-            holdingEscrow {
-              asset {
-                decimals
-                assetTokenId
-                address
-                name
-                symbol
-                blockchain {
-                  id
-                }
+            asset {
+              decimals
+              assetTokenId
+              address
+              name
+              symbol
+              blockchain {
+                id
               }
             }
           }
         }
       }`, {
             scId: this.id.raw,
-        });
+        }, (data) => data.holdingEscrows.items);
+    }
+    /** @internal */
+    _holding(assetId) {
+        return this._query(['holding', assetId.toString()], () => combineLatest([this._root._protocolAddresses(this.pool.chainId), this.pool.currency()]).pipe(switchMap(([{ holdings: holdingsAddr, hubRegistry }, poolCurrency]) => defer(async () => {
+            const holdings = getContract({
+                address: holdingsAddr,
+                abi: ABI.Holdings,
+                client: this._root.getClient(this.pool.chainId),
+            });
+            const [valuation, amount, value, assetDecimals, isLiability, ...accounts] = await Promise.all([
+                holdings.read.valuation([this.pool.id.raw, this.id.raw, assetId.raw]),
+                holdings.read.amount([this.pool.id.raw, this.id.raw, assetId.raw]),
+                holdings.read.value([this.pool.id.raw, this.id.raw, assetId.raw]),
+                this._root.getClient(this.pool.chainId).readContract({
+                    address: hubRegistry,
+                    // Use inline ABI because of function overload
+                    abi: parseAbi(['function decimals(uint256) view returns (uint8)']),
+                    functionName: 'decimals',
+                    args: [assetId.raw],
+                }),
+                holdings.read.isLiability([this.pool.id.raw, this.id.raw, assetId.raw]),
+                ...[
+                    AccountType.Asset,
+                    AccountType.Equity,
+                    AccountType.Loss,
+                    AccountType.Gain,
+                    AccountType.Expense,
+                    AccountType.Liability,
+                ].map((kind) => holdings.read.accountId([this.pool.id.raw, this.id.raw, assetId.raw, kind])),
+            ]);
+            return {
+                assetId,
+                assetDecimals,
+                valuation,
+                amount: new Balance(amount, assetDecimals),
+                value: new Balance(value, poolCurrency.decimals),
+                isLiability,
+                accounts: {
+                    [AccountType.Asset]: accounts[0] || null,
+                    [AccountType.Equity]: accounts[1] || null,
+                    [AccountType.Loss]: accounts[2] || null,
+                    [AccountType.Gain]: accounts[3] || null,
+                    [AccountType.Expense]: accounts[4] || null,
+                    [AccountType.Liability]: accounts[5] || null,
+                },
+            };
+        }).pipe(repeatOnEvents(this._root, {
+            address: holdingsAddr,
+            abi: ABI.Holdings,
+            eventName: ['Increase', 'Decrease', 'Update', 'UpdateValuation'],
+            filter: (events) => {
+                return events.some((event) => {
+                    return event.args.scId === this.id && event.args.assetId === assetId.raw;
+                });
+            },
+        }, this.pool.chainId)))));
+    }
+    /** @internal */
+    _balance(chainId, asset) {
+        return this._query(['balance', asset.id.toString()], () => combineLatest([this._root._protocolAddresses(chainId), this.pool.currency()]).pipe(switchMap(([addresses, poolCurrency]) => defer(async () => {
+            const client = this._root.getClient(chainId);
+            const [amountBn, priceBn] = await Promise.all([
+                client.readContract({
+                    address: addresses.balanceSheet,
+                    abi: ABI.BalanceSheet,
+                    functionName: 'availableBalanceOf',
+                    args: [this.pool.id.raw, this.id.raw, asset.address, BigInt(asset.assetTokenId ?? 0n)],
+                }),
+                client.readContract({
+                    address: addresses.spoke,
+                    abi: ABI.Spoke,
+                    functionName: 'pricePoolPerAsset',
+                    args: [this.pool.id.raw, this.id.raw, asset.id.raw, false],
+                }),
+            ]);
+            console.log('addresses.spoke', addresses.spoke);
+            console.log('priceBn', priceBn, this.pool.id.raw, this.id.raw, asset.id.raw);
+            const amount = new Balance(amountBn, asset.decimals);
+            const price = new Price(priceBn);
+            const value = Balance.fromFloat(amount.toDecimal().mul(price.toDecimal()), poolCurrency.decimals);
+            return {
+                amount,
+                value,
+                price,
+            };
+        }).pipe(repeatOnEvents(this._root, {
+            address: [addresses.balanceSheet, addresses.spoke],
+            abi: [ABI.ShareClassManager, ABI.Spoke],
+            eventName: ['NoteDeposit', 'Deposit', 'Withdraw', 'UpdateAssetPrice'],
+            filter: (events) => {
+                return events.some((event) => event.args.scId === this.id.raw &&
+                    // UpdateAssetPrice event
+                    (event.args.assetId === asset.id.raw ||
+                        // NoteDeposit, Deposit, Withdraw events
+                        event.args.asset?.toLowerCase() === asset.address?.toLowerCase()));
+            },
+        }, chainId)))));
     }
     /** @internal */
     _allVaults() {
@@ -761,23 +829,20 @@ export class ShareClass extends Entity {
     }
     /** @internal */
     _epoch(assetId) {
-        return this._query(['epoch', assetId.toString()], () => this._root._protocolAddresses(this.pool.chainId).pipe(switchMap(({ shareClassManager, hubRegistry }) => defer(async () => {
+        return this._query(['epoch', assetId.toString()], () => combineLatest([
+            this._root._protocolAddresses(this.pool.chainId),
+            this.pool.currency(),
+            this._root.assetDecimals(assetId, this.pool.chainId),
+        ]).pipe(switchMap(([{ shareClassManager }, poolCurrency, assetDecimals]) => defer(async () => {
             const scm = getContract({
                 address: shareClassManager,
                 abi: ABI.ShareClassManager,
                 client: this._root.getClient(this.pool.chainId),
             });
-            const [epoch, pendingDeposit, pendingRedeem, assetDecimals] = await Promise.all([
+            const [epoch, pendingDeposit, pendingRedeem] = await Promise.all([
                 scm.read.epochId([this.id.raw, assetId.raw]),
                 scm.read.pendingDeposit([this.id.raw, assetId.raw]),
                 scm.read.pendingRedeem([this.id.raw, assetId.raw]),
-                this._root.getClient(this.pool.chainId).readContract({
-                    address: hubRegistry,
-                    // Use inline ABI because of function overload
-                    abi: parseAbi(['function decimals(uint256) view returns (uint8)']),
-                    functionName: 'decimals',
-                    args: [assetId.raw],
-                }),
             ]);
             const depositEpoch = epoch[0];
             const redeemEpoch = epoch[1];
@@ -794,12 +859,10 @@ export class ShareClass extends Entity {
                 redeemEpoch,
                 issueEpoch,
                 revokeEpoch,
-                // TODO: Replace with assetDecimals()
                 pendingDeposit: new Balance(pendingDeposit, assetDecimals),
-                // TODO: Replace with assetDecimals()
-                pendingRedeem: new Balance(pendingRedeem, 18),
+                pendingRedeem: new Balance(pendingRedeem, poolCurrency.decimals),
                 approvedDeposit: new Balance(approvedDeposit, assetDecimals),
-                approvedRedeem: new Balance(approvedRedeem, 18),
+                approvedRedeem: new Balance(approvedRedeem, poolCurrency.decimals),
             };
         }).pipe(repeatOnEvents(this._root, {
             address: shareClassManager,
@@ -824,19 +887,20 @@ export class ShareClass extends Entity {
     /** @internal */
     _updateContract(chainId, target, payload) {
         const self = this;
-        return this._transact(async function* ({ walletClient, publicClient }) {
-            const id = await self._root.id(chainId);
-            const [{ hub }, estimate] = await Promise.all([
+        return this._transact(async function* (ctx) {
+            const [id, { hub }] = await Promise.all([
+                self._root.id(chainId),
                 self._root._protocolAddresses(self.pool.chainId),
-                self._root._estimate(self.pool.chainId, { centId: id }),
             ]);
-            yield* doTransaction('Update contract', publicClient, () => walletClient.writeContract({
-                address: hub,
-                abi: ABI.Hub,
-                functionName: 'updateContract',
-                args: [self.pool.id.raw, self.id.raw, id, addressToBytes32(target), payload, 0n],
-                value: estimate,
-            }));
+            yield* wrapTransaction('Update contract', ctx, {
+                contract: hub,
+                data: encodeFunctionData({
+                    abi: ABI.Hub,
+                    functionName: 'updateContract',
+                    args: [self.pool.id.raw, self.id.raw, id, addressToBytes32(target), payload, 0n],
+                }),
+                messages: { [id]: [MessageType.UpdateContract] },
+            });
         }, this.pool.chainId);
     }
     /** @internal */