@centrifuge/sdk 0.0.0-alpha.3 → 0.0.0-alpha.31

package/dist/entities/ShareClass.js

@@ -0,0 +1,978 @@
+import { catchError, combineLatest, defer, EMPTY, expand, filter, map, of, switchMap } from 'rxjs';
+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 { 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.
+ */
+export class ShareClass extends Entity {
+    pool;
+    id;
+    /** @internal */
+    constructor(_root, pool, id) {
+        const _id = id instanceof ShareClassId ? id : new ShareClassId(id);
+        super(_root, ['shareclass', _id.toString()]);
+        this.pool = pool;
+        this.id = _id;
+    }
+    /**
+     * Query the details of the share class.
+     * @returns The details of the share class, including name, symbol, total issuance, NAV per share and relavant metadata from the pool metadata.
+     */
+    details() {
+        return this._query(null, () => combineLatest([
+            this._metrics(),
+            this._metadata(),
+            this.navPerNetwork(),
+            this.pool.currency(),
+            this.pool.metadata(),
+        ]).pipe(map(([metrics, metadata, navPerNetwork, poolCurrency, poolMeta]) => {
+            const totalIssuance = navPerNetwork.reduce((acc, item) => acc.add(item.totalIssuance), new Balance(0n, poolCurrency.decimals));
+            const meta = poolMeta?.shareClasses?.[this.id.raw];
+            return {
+                id: this.id,
+                name: metadata.name,
+                symbol: metadata.symbol,
+                totalIssuance,
+                pricePerShare: metrics.pricePerShare,
+                nav: totalIssuance.mul(metrics.pricePerShare),
+                navPerNetwork,
+                icon: meta?.icon || null,
+                minInitialInvestment: meta?.minInitialInvestment || null,
+                apyPercentage: meta?.apyPercentage || null,
+                apy: meta?.apy || null,
+                defaultAccounts: {
+                    asset: meta?.defaultAccounts?.asset || null,
+                    equity: meta?.defaultAccounts?.equity || null,
+                    gain: meta?.defaultAccounts?.gain || null,
+                    loss: meta?.defaultAccounts?.loss || null,
+                    expense: meta?.defaultAccounts?.expense || null,
+                    liability: meta?.defaultAccounts?.liability || null,
+                },
+            };
+        })));
+    }
+    balanceSheet(chainId) {
+        return this._query(null, () => this.pool.activeNetworks().pipe(map((networks) => {
+            const network = networks.find((n) => n.chainId === chainId);
+            if (!network) {
+                throw new Error(`No active network found for chain ID ${chainId}`);
+            }
+            return new BalanceSheet(this._root, network, this);
+        })));
+    }
+    navPerNetwork() {
+        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, poolCurrency.decimals),
+            pricePerShare: 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 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, () => 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 balances of the share class (from BalanceSheet and Holdings).
+     */
+    balances(chainId) {
+        return this._query(null, () => combineLatest([this._balances(), this.pool.currency()]).pipe(switchMap(([res, poolCurrency]) => {
+            if (res.length === 0) {
+                return of([]);
+            }
+            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 {
+                    assetId: new AssetId(data.assetId),
+                    amount: balance.amount,
+                    value,
+                    price,
+                    asset: {
+                        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,
+                    },
+                };
+            })));
+        })));
+    }
+    /**
+     * Get the pending and approved amounts for deposits and redemptions for each asset.
+     */
+    pendingAmounts() {
+        return this._query(null, () => this._allVaults().pipe(switchMap((vaults) => {
+            if (vaults.length === 0) {
+                return of([]);
+            }
+            return combineLatest(vaults.map((vault) => this._epoch(vault.assetId))).pipe(map((epochs) => {
+                return epochs.map((epoch, i) => {
+                    const vault = vaults[i];
+                    return {
+                        assetId: vault.assetId,
+                        chainId: vault.chainId,
+                        ...epoch,
+                    };
+                });
+            }));
+        })));
+    }
+    investorOrder(assetId, investor) {
+        return this._query(['maxClaims', assetId.toString(), investor.toLowerCase()], () => this._root._protocolAddresses(this.pool.chainId).pipe(switchMap(({ shareClassManager }) => defer(async () => {
+            const contract = getContract({
+                address: shareClassManager,
+                abi: ABI.ShareClassManager,
+                client: this._root.getClient(this.pool.chainId),
+            });
+            const [maxDepositClaims, maxRedeemClaims] = await Promise.all([
+                contract.read.maxDepositClaims([this.id.raw, addressToBytes32(investor), assetId.raw]),
+                contract.read.maxRedeemClaims([this.id.raw, addressToBytes32(investor), assetId.raw]),
+            ]);
+            return {
+                maxDepositClaims,
+                maxRedeemClaims,
+            };
+        }).pipe(repeatOnEvents(this._root, {
+            address: shareClassManager,
+            abi: ABI.ShareClassManager,
+            eventName: [
+                'UpdateDepositRequest',
+                'UpdateRedeemRequest',
+                'ClaimDeposit',
+                'ClaimRedeem',
+                'ApproveDeposits',
+                'ApproveRedeems',
+            ],
+            filter: (events) => {
+                return events.some((event) => event.args.scId === this.id.raw &&
+                    (event.args.depositAssetId === assetId.raw || event.args.payoutAssetId === assetId.raw));
+            },
+        }, this.pool.chainId)))));
+    }
+    /**
+     * Check if an address is a member of the share class.
+     * @param address Address to check
+     * @param chainId Chain ID of the network on which to check the member
+     */
+    member(address, chainId) {
+        const addr = address.toLowerCase();
+        return this._query(['member', addr, chainId], () => combineLatest([this._share(chainId), this._restrictionManager(chainId)]).pipe(switchMap(([share, restrictionManager]) => defer(async () => {
+            const res = await this._root.getClient(this.pool.chainId).readContract({
+                address: restrictionManager,
+                abi: ABI.RestrictionManager,
+                functionName: 'isMember',
+                args: [share, addr],
+            });
+            return {
+                isMember: res[0],
+                validUntil: new Date(Number(res[1]) * 1000),
+            };
+        }).pipe(repeatOnEvents(this._root, {
+            address: restrictionManager,
+            abi: ABI.RestrictionManager,
+            eventName: 'UpdateMember',
+            filter: (events) => events.some((event) => event.args.user?.toLowerCase() === addr && event.args.token?.toLowerCase() === share),
+        }, chainId), catchError(() => {
+            // Freeze-only hook doesn't have isMember function
+            return of({
+                isMember: false,
+                validUntil: new Date(0),
+            });
+        })))));
+    }
+    /**
+     * Create a holding for a registered asset in the share class.
+     * @param assetId - Asset ID of the asset to create a holding for
+     * @param valuation - Valuation of the asset
+     * @param isLiability - Whether the holding is a liability or not
+     * @param accounts - Accounts to use for the holding. An asset or expense account will be created if not provided.
+     * Other accounts are expected to be provided or to exist in the pool metadata.
+     */
+    createHolding(assetId, valuation, isLiability, accounts) {
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const [{ hub }, metadata] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                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];
+                }
+            }
+            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];
+                }
+            }
+            yield* wrapTransaction('Create holding', ctx, {
+                contract: hub,
+                data,
+            });
+        }, this.pool.chainId);
+    }
+    updateSharePrice(pricePerShare) {
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const { hub } = await self._root._protocolAddresses(self.pool.chainId);
+            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* (ctx) {
+            const { hub } = await self._root._protocolAddresses(self.pool.chainId);
+            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* (ctx) {
+            const [{ hub }, id] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                self._root.id(chainId),
+            ]);
+            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* (ctx) {
+            const { hub } = await self._root._protocolAddresses(self.pool.chainId);
+            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* (ctx) {
+            const [{ hub }, id] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                self._root.id(chainId),
+            ]);
+            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);
+    }
+    /**
+     * Approve deposits and issue shares for the given assets.
+     * @param assets - Array of assets to approve deposits and/or issue shares for
+     * `issuePricePerShare` can be a single price for all epochs or an array of prices for each epoch to be issued for.
+     */
+    approveDepositsAndIssueShares(assets) {
+        // TODO: Also claim orders
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const [{ hub }, pendingAmounts] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                self.pendingAmounts(),
+            ]);
+            const batch = [];
+            const messages = {};
+            function addMessage(centId, message) {
+                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) {
+                    throw new Error(`No pending amount found for asset "${asset.assetId.toString()}"`);
+                }
+                let nowDepositEpoch = pending?.depositEpoch;
+                if (asset.approveAssetAmount) {
+                    if (asset.approveAssetAmount.gt(pending.pendingDeposit)) {
+                        throw new Error(`Approve amount exceeds pending amount for asset "${asset.assetId.toString()}"`);
+                    }
+                    if (asset.approveAssetAmount.lte(0n)) {
+                        throw new Error(`Approve amount must be greater than 0 for asset "${asset.assetId.toString()}"`);
+                    }
+                    batch.push(encodeFunctionData({
+                        abi: ABI.Hub,
+                        functionName: 'approveDeposits',
+                        args: [
+                            self.pool.id.raw,
+                            self.id.raw,
+                            asset.assetId.raw,
+                            nowDepositEpoch,
+                            asset.approveAssetAmount.toBigInt(),
+                        ],
+                    }));
+                    addMessage(asset.assetId.centrifugeId, MessageType.RequestCallback);
+                    nowDepositEpoch++;
+                }
+                const nowIssueEpoch = pending.issueEpoch;
+                if (asset.issuePricePerShare) {
+                    if (nowIssueEpoch >= nowDepositEpoch)
+                        throw new Error('Nothing to issue');
+                    for (let i = 0; i < nowDepositEpoch - nowIssueEpoch; i++) {
+                        const price = Array.isArray(asset.issuePricePerShare)
+                            ? asset.issuePricePerShare[i]
+                            : asset.issuePricePerShare;
+                        if (!price)
+                            break;
+                        if (price.lte(0n)) {
+                            throw new Error(`Issue price per share must be greater than 0 for asset "${asset.assetId.toString()}"`);
+                        }
+                        batch.push(encodeFunctionData({
+                            abi: ABI.Hub,
+                            functionName: 'issueShares',
+                            args: [self.pool.id.raw, self.id.raw, asset.assetId.raw, nowIssueEpoch + i, price.toBigInt(), 0n],
+                        }));
+                        addMessage(asset.assetId.centrifugeId, MessageType.RequestCallback);
+                    }
+                }
+            }
+            if (batch.length === 0) {
+                throw new Error('No approve or issue actions provided');
+            }
+            yield* wrapTransaction('Approve and issue', ctx, {
+                contract: hub,
+                data: batch,
+                messages,
+            });
+        }, this.pool.chainId);
+    }
+    /**
+     * Approve redeems and revoke shares for the given assets.
+     * @param assets - Array of assets to approve redeems and/or revoke shares for
+     * `approveShareAmount` can be a single amount for all epochs or an array of amounts for each epoch to be revoked.
+     */
+    approveRedeemsAndRevokeShares(assets) {
+        // TODO: Also claim orders
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const [{ hub }, pendingAmounts] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                self.pendingAmounts(),
+            ]);
+            const batch = [];
+            const messages = {};
+            function addMessage(centId, message) {
+                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) {
+                    throw new Error(`No pending amount found for asset "${asset.assetId.toString()}"`);
+                }
+                let nowRedeemEpoch = pending.redeemEpoch;
+                if (asset.approveShareAmount) {
+                    if (asset.approveShareAmount.gt(pending.pendingRedeem)) {
+                        throw new Error(`Share amount exceeds pending redeem for asset "${asset.assetId.toString()}"`);
+                    }
+                    if (asset.approveShareAmount.lte(0n)) {
+                        throw new Error(`Share amount must be greater than 0 for asset "${asset.assetId.toString()}"`);
+                    }
+                    batch.push(encodeFunctionData({
+                        abi: ABI.Hub,
+                        functionName: 'approveRedeems',
+                        args: [
+                            self.pool.id.raw,
+                            self.id.raw,
+                            asset.assetId.raw,
+                            nowRedeemEpoch,
+                            asset.approveShareAmount.toBigInt(),
+                        ],
+                    }));
+                    nowRedeemEpoch++;
+                }
+                const nowRevokeEpoch = pending.revokeEpoch;
+                if (asset.revokePricePerShare) {
+                    if (nowRevokeEpoch >= nowRedeemEpoch)
+                        throw new Error('Nothing to revoke');
+                    for (let i = 0; i < nowRedeemEpoch - nowRevokeEpoch; i++) {
+                        const price = Array.isArray(asset.revokePricePerShare)
+                            ? asset.revokePricePerShare[i]
+                            : asset.revokePricePerShare;
+                        if (!price)
+                            break;
+                        if (price.lte(0n)) {
+                            throw new Error(`Revoke price per share must be greater than 0 for asset "${asset.assetId.toString()}"`);
+                        }
+                        batch.push(encodeFunctionData({
+                            abi: ABI.Hub,
+                            functionName: 'revokeShares',
+                            args: [self.pool.id.raw, self.id.raw, asset.assetId.raw, nowRevokeEpoch + i, price.toBigInt(), 0n],
+                        }));
+                        addMessage(asset.assetId.centrifugeId, MessageType.RequestCallback);
+                    }
+                }
+            }
+            if (batch.length === 0) {
+                throw new Error('No approve or revoke actions provided');
+            }
+            yield* wrapTransaction('Approve and revoke', ctx, {
+                contract: hub,
+                data: batch,
+                messages,
+            });
+        }, this.pool.chainId);
+    }
+    /**
+     * Claim a deposit on the Hub side for the given asset and investor after the shares have been issued.
+     * This will send a message to the Spoke that will allow the investor to claim their shares.
+     */
+    claimDeposit(assetId, investor) {
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const [{ hub }, investorOrder] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                self.investorOrder(assetId, investor),
+            ]);
+            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);
+    }
+    /**
+     * Claim a redemption on the Hub side for the given asset and investor after the shares have been revoked.
+     * This will send a message to the Spoke that will allow the investor to claim their redeemed currency.
+     */
+    claimRedeem(assetId, investor) {
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const [{ hub }, investorOrder] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                self.investorOrder(assetId, investor),
+            ]);
+            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);
+    }
+    /**
+     * Update a member of the share class.
+     * @param address Address of the investor
+     * @param validUntil Time in seconds from Unix epoch until the investor is valid
+     * @param chainId Chain ID of the network on which to update the member
+     */
+    updateMember(address, validUntil, chainId) {
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const [{ hub }, id] = await Promise.all([
+                self._root._protocolAddresses(self.pool.chainId),
+                self._root.id(chainId),
+            ]);
+            const payload = encodePacked(['uint8', 'bytes32', 'uint64'], [/* UpdateRestrictionType.Member */ 1, addressToBytes32(address), BigInt(validUntil)]);
+            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 */
+    _balances() {
+        return this._root._queryIndexer(`query ($scId: String!) {
+        holdingEscrows(where: { tokenId: $scId }) {
+          items {
+            holding {
+              updatedAt
+            }
+            assetAmount
+            assetPrice
+            assetId
+            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() {
+        return this._root._queryIndexer(`query ($scId: String!) {
+          vaults(where: { tokenId: $scId }) {
+            items {
+              asset {
+                id
+              }
+              address: id
+              poolId
+              assetAddress
+              blockchain {
+                id
+              }
+            }
+          }
+        }`, { scId: this.id.raw }, (data) => data.vaults.items.map(({ blockchain, asset, ...rest }) => ({
+            ...rest,
+            chainId: Number(blockchain.id),
+            assetId: new AssetId(asset.id),
+        })));
+    }
+    /** @internal */
+    _metadata() {
+        return this._query(['metadata'], () => this._root._protocolAddresses(this.pool.chainId).pipe(switchMap(({ shareClassManager }) => defer(async () => {
+            const [name, symbol] = await this._root.getClient(this.pool.chainId).readContract({
+                address: shareClassManager,
+                abi: ABI.ShareClassManager,
+                functionName: 'metadata',
+                args: [this.id.raw],
+            });
+            return {
+                name,
+                symbol,
+            };
+        }).pipe(repeatOnEvents(this._root, {
+            address: shareClassManager,
+            abi: ABI.ShareClassManager,
+            eventName: 'UpdateMetadata',
+            filter: (events) => {
+                return events.some((event) => {
+                    return event.args.scId === this.id;
+                });
+            },
+        }, this.pool.chainId)))));
+    }
+    /** @internal */
+    _metrics() {
+        return this._query(['metrics'], () => this._root._protocolAddresses(this.pool.chainId).pipe(switchMap(({ shareClassManager }) => defer(async () => {
+            const [totalIssuance, pricePerShare] = await this._root.getClient(this.pool.chainId).readContract({
+                address: shareClassManager,
+                abi: ABI.ShareClassManager,
+                functionName: 'metrics',
+                args: [this.id.raw],
+            });
+            return {
+                totalIssuance: new Balance(totalIssuance, 18),
+                pricePerShare: new Price(pricePerShare),
+            };
+        }).pipe(repeatOnEvents(this._root, {
+            address: shareClassManager,
+            abi: ABI.ShareClassManager,
+            eventName: [
+                'RevokeShares',
+                'IssueShares',
+                'RemoteIssueShares',
+                'RemoteRevokeShares',
+                'UpdateShareClass',
+            ],
+            filter: (events) => {
+                return events.some((event) => {
+                    return event.args.scId === this.id.raw;
+                });
+            },
+        }, this.pool.chainId)))));
+    }
+    /** @internal */
+    _epoch(assetId) {
+        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] = 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]),
+            ]);
+            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.id.raw, assetId.raw, issueEpoch + i]))),
+                Promise.all(Array.from({ length: redeemEpoch - revokeEpoch }).map((_, i) => scm.read.epochRedeemAmounts([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: new Date('2025'), // TODO: Get from indexer
+                    epoch: issueEpoch + i,
+                })),
+                pendingRevocationsTotal: new Balance(approvedRedeem, poolCurrency.decimals),
+                pendingRevocations: redeemEpochAmount.map(([, amount], i) => ({
+                    amount: new Balance(amount, poolCurrency.decimals),
+                    approvedAt: new Date('2025'), // TODO: Get from indexer
+                    epoch: revokeEpoch + i,
+                })),
+            };
+        }).pipe(repeatOnEvents(this._root, {
+            address: shareClassManager,
+            abi: ABI.ShareClassManager,
+            eventName: [
+                'ApproveDeposits',
+                'ApproveRedeems',
+                'IssueShares',
+                'RevokeShares',
+                'RemoteIssueShares',
+                'RemoteRevokeShares',
+                'UpdateDepositRequest',
+                'UpdateRedeemRequest',
+            ],
+            filter: (events) => {
+                return events.some((event) => {
+                    return event.args.scId === this.id.raw;
+                });
+            },
+        }, this.pool.chainId)))));
+    }
+    /** @internal */
+    _updateContract(chainId, target, payload) {
+        const self = this;
+        return this._transact(async function* (ctx) {
+            const [id, { hub }] = await Promise.all([
+                self._root.id(chainId),
+                self._root._protocolAddresses(self.pool.chainId),
+            ]);
+            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 */
+    _share(chainId) {
+        return this._query(null, () => this.pool.network(chainId).pipe(switchMap((network) => network._share(this.id))));
+    }
+    /** @internal */
+    _restrictionManager(chainId) {
+        return this._query(['restrictionManager', chainId], () => this._share(chainId).pipe(switchMap((share) => defer(async () => {
+            const address = await this._root.getClient(this.pool.chainId).readContract({
+                address: share,
+                abi: ABI.Currency,
+                functionName: 'hook',
+            });
+            return address.toLowerCase();
+        }))));
+    }
+    /** @internal */
+    _getFreeAccountId() {
+        return this._query(null, () => this._root._protocolAddresses(this.pool.chainId).pipe(map(({ accounting }) => ({ accounting, id: null, triesLeft: 10 })), expand(({ accounting, triesLeft }) => {
+            const id = Number(randomUint(32));
+            if (triesLeft <= 0)
+                return EMPTY;
+            return defer(async () => {
+                const exists = await this._root.getClient(this.pool.chainId).readContract({
+                    address: accounting,
+                    abi: ABI.Accounting,
+                    functionName: 'exists',
+                    args: [this.pool.id.raw, id],
+                });
+                return { accounting, id: exists ? null : id, triesLeft: triesLeft - 1 };
+            });
+        }), filter(({ id }) => !!id), map(({ id }) => id)));
+    }
+}
+//# sourceMappingURL=ShareClass.js.map