@centrifuge/sdk 0.0.0-alpha.5 → 0.0.0-alpha.50

package/dist/Centrifuge.js

@@ -1,40 +1,35 @@
-import { concatWith, defaultIfEmpty, defer, filter, identity, isObservable, map, mergeMap, of, Subject, switchMap, using, } from 'rxjs';
+import { combineLatest, concatWith, defaultIfEmpty, defer, filter, first, identity, isObservable, map, mergeMap, of, Subject, switchMap, timer, using, } from 'rxjs';
 import { fromFetch } from 'rxjs/fetch';
-import { createPublicClient, createWalletClient, custom, getContract, http, parseEventLogs, } from 'viem';
+import { createPublicClient, createWalletClient, custom, encodeFunctionData, fallback, getContract, http, parseAbi, parseEventLogs, toHex, } from 'viem';
 import { ABI } from './abi/index.js';
-import { Account } from './Account.js';
 import { chains } from './config/chains.js';
 import { PERMIT_TYPEHASH } from './constants.js';
-import { Pool } from './Pool.js';
-import { Currency } from './utils/BigInt.js';
+import { Investor } from './entities/Investor.js';
+import { Pool } from './entities/Pool.js';
+import { emptyMessage, MessageType, } from './types/transaction.js';
+import { Balance } from './utils/BigInt.js';
+import { randomUint } from './utils/index.js';
+import { createPinning, getUrlFromHash } from './utils/ipfs.js';
 import { hashKey } from './utils/query.js';
 import { makeThenable, repeatOnEvents, shareReplayWithDelayedReset } from './utils/rx.js';
-import { doTransaction, isLocalAccount } from './utils/transaction.js';
+import { doTransaction, isLocalAccount, wrapTransaction } from './utils/transaction.js';
+import { AssetId, PoolId, ShareClassId } from './utils/types.js';
+const PINNING_API_DEMO = 'https://europe-central2-peak-vista-185616.cloudfunctions.net/pinning-api-demo';
 const envConfig = {
     mainnet: {
-        indexerUrl: 'https://subql.embrio.tech/',
-        alchemyKey: 'KNR-1LZhNqWOxZS2AN8AFeaiESBV10qZ',
-        infuraKey: '8ed99a9a115349bbbc01dcf3a24edc96',
-        defaultChain: 1,
+        indexerUrl: 'https://api.centrifuge.io',
         ipfsUrl: 'https://centrifuge.mypinata.cloud',
+        ...createPinning(PINNING_API_DEMO),
     },
-    demo: {
-        indexerUrl: 'https://api.subquery.network/sq/centrifuge/pools-demo-multichain',
-        alchemyKey: 'KNR-1LZhNqWOxZS2AN8AFeaiESBV10qZ',
-        infuraKey: '8cd8e043ee8d4001b97a1c37e08fd9dd',
-        defaultChain: 11155111,
-        ipfsUrl: 'https://centrifuge.mypinata.cloud',
-    },
-    dev: {
-        indexerUrl: 'https://api.subquery.network/sq/centrifuge/pools-demo-multichain',
-        alchemyKey: 'KNR-1LZhNqWOxZS2AN8AFeaiESBV10qZ',
-        infuraKey: '8cd8e043ee8d4001b97a1c37e08fd9dd',
-        defaultChain: 11155111,
+    testnet: {
+        indexerUrl: 'https://api-v3-hitz.marble.live/graphql',
         ipfsUrl: 'https://centrifuge.mypinata.cloud',
+        ...createPinning(PINNING_API_DEMO),
     },
 };
 const defaultConfig = {
     environment: 'mainnet',
+    cache: true,
 };
 export class Centrifuge {
     #config;
@@ -43,13 +38,16 @@ export class Centrifuge {
     }
     #clients = new Map();
     getClient(chainId) {
-        return this.#clients.get(chainId ?? this.config.defaultChain);
+        const client = this.#clients.get(chainId);
+        if (!client)
+            throw new Error(`No client found for chain ID "${chainId}"`);
+        return client;
     }
     get chains() {
         return [...this.#clients.keys()];
     }
     getChainConfig(chainId) {
-        return this.getClient(chainId ?? this.config.defaultChain).chain;
+        return this.getClient(chainId).chain;
     }
     #signer = null;
     setSigner(signer) {
@@ -58,8 +56,9 @@ export class Centrifuge {
     get signer() {
         return this.#signer;
     }
+    #isBatching = new WeakSet();
     constructor(config = {}) {
-        const defaultConfigForEnv = envConfig[config?.environment ?? 'mainnet'];
+        const defaultConfigForEnv = envConfig[config?.environment || 'mainnet'];
         this.#config = {
             ...defaultConfig,
             ...defaultConfigForEnv,
@@ -73,47 +72,253 @@ export class Centrifuge {
             if (!rpcUrl) {
                 console.warn(`No rpcUrl defined for chain ${chain.id}. Using public RPC endpoint.`);
             }
-            this.#clients.set(chain.id, createPublicClient({ chain, transport: http(rpcUrl), batch: { multicall: true } }));
+            this.#clients.set(chain.id, createPublicClient({
+                chain,
+                transport: Array.isArray(rpcUrl)
+                    ? fallback(rpcUrl.map((url) => http(url)), {
+                        rank: {
+                            interval: 30_000,
+                            sampleCount: 5,
+                        },
+                    })
+                    : http(rpcUrl),
+                batch: { multicall: true },
+                pollingInterval: this.#config.pollingInterval,
+                cacheTime: 100,
+            }));
         });
     }
-    pool(id, metadataHash) {
-        return this._query(null, () => of(new Pool(this, id, metadataHash)));
+    /**
+     * Create a new pool on the given chain.
+     * @param metadataInput - The metadata for the pool
+     * @param currencyCode - The currency code for the pool
+     * @param chainId - The chain ID to create the pool on
+     * @param counter - The pool counter, used to create a unique pool ID (uint48)
+     */
+    createPool(metadataInput, currencyCode = 840, chainId, counter) {
+        const self = this;
+        return this._transact(async function* ({ walletClient, signingAddress, publicClient }) {
+            const [addresses, id] = await Promise.all([self._protocolAddresses(chainId), self.id(chainId)]);
+            const poolId = PoolId.from(id, counter ?? randomUint(48));
+            const createPoolData = encodeFunctionData({
+                abi: ABI.Hub,
+                functionName: 'createPool',
+                args: [poolId.raw, signingAddress, BigInt(currencyCode)],
+            });
+            const scIds = Array.from({ length: metadataInput.shareClasses.length }, (_, i) => ShareClassId.from(poolId, i + 1));
+            const shareClassesById = {};
+            metadataInput.shareClasses.forEach((sc, index) => {
+                shareClassesById[scIds[index].raw] = {
+                    minInitialInvestment: sc.minInvestment,
+                    apyPercentage: sc.apyPercentage,
+                    apy: sc.apy,
+                    defaultAccounts: sc.defaultAccounts,
+                };
+            });
+            const formattedMetadata = {
+                version: 1,
+                pool: {
+                    name: metadataInput.poolName,
+                    icon: metadataInput.poolIcon,
+                    asset: {
+                        class: metadataInput.assetClass,
+                        subClass: metadataInput.subAssetClass,
+                    },
+                    issuer: {
+                        name: metadataInput.issuerName,
+                        repName: metadataInput.issuerRepName,
+                        description: metadataInput.issuerDescription,
+                        email: metadataInput.email,
+                        logo: metadataInput.issuerLogo,
+                        shortDescription: metadataInput.issuerShortDescription,
+                        categories: metadataInput.issuerCategories,
+                    },
+                    poolStructure: metadataInput.poolStructure,
+                    investorType: metadataInput.investorType,
+                    links: {
+                        executiveSummary: metadataInput.executiveSummary,
+                        forum: metadataInput.forum,
+                        website: metadataInput.website,
+                    },
+                    details: metadataInput.details,
+                    status: 'open',
+                    listed: metadataInput.listed ?? true,
+                    poolRatings: metadataInput.poolRatings.length > 0 ? metadataInput.poolRatings : [],
+                    reports: metadataInput.report
+                        ? [
+                            {
+                                author: {
+                                    name: metadataInput.report.author.name,
+                                    title: metadataInput.report.author.title,
+                                    avatar: metadataInput.report.author.avatar,
+                                },
+                                uri: metadataInput.report.uri,
+                            },
+                        ]
+                        : [],
+                },
+                shareClasses: shareClassesById,
+                onboarding: {
+                    shareClasses: metadataInput.onboarding?.shareClasses || {},
+                    taxInfoRequired: metadataInput.onboarding?.taxInfoRequired,
+                    externalOnboardingUrl: metadataInput.onboarding?.externalOnboardingUrl,
+                },
+            };
+            const cid = await self.config.pinJson(formattedMetadata);
+            const setMetadataData = encodeFunctionData({
+                abi: ABI.Hub,
+                functionName: 'setPoolMetadata',
+                args: [poolId.raw, toHex(cid)],
+            });
+            const addScData = metadataInput.shareClasses.map((sc) => encodeFunctionData({
+                abi: ABI.Hub,
+                functionName: 'addShareClass',
+                args: [
+                    poolId.raw,
+                    sc.tokenName,
+                    sc.symbolName,
+                    sc.salt?.startsWith('0x') ? sc.salt : toHex(sc.salt ?? randomUint(256), { size: 32 }),
+                ],
+            }));
+            const accountIsDebitNormal = new Map();
+            const accountNumbers = [
+                ...new Set(metadataInput.shareClasses.flatMap((sc) => Object.entries(sc.defaultAccounts ?? {})
+                    .filter(([k, v]) => {
+                    if (!v)
+                        return false;
+                    if (['asset', 'expense'].includes(k)) {
+                        if (accountIsDebitNormal.get(v) === false)
+                            throw new Error(`Account "${v}" is set as both credit normal and debit normal.`);
+                        accountIsDebitNormal.set(v, true);
+                    }
+                    else {
+                        if (accountIsDebitNormal.get(v) === true)
+                            throw new Error(`Account "${v}" is set as both credit normal and debit normal.`);
+                        accountIsDebitNormal.set(v, false);
+                    }
+                    return true;
+                })
+                    .map(([, v]) => v))),
+            ];
+            const createAccountsData = accountNumbers.map((account) => encodeFunctionData({
+                abi: ABI.Hub,
+                functionName: 'createAccount',
+                args: [poolId.raw, account, accountIsDebitNormal.get(account)],
+            }));
+            yield* doTransaction('Create pool', publicClient, () => {
+                return walletClient.writeContract({
+                    address: addresses.hub,
+                    abi: ABI.Hub,
+                    functionName: 'multicall',
+                    args: [[createPoolData, setMetadataData, ...addScData, ...createAccountsData]],
+                });
+            });
+        }, chainId);
     }
-    account(address, chainId) {
-        return this._query(null, () => of(new Account(this, address, chainId ?? this.config.defaultChain)));
+    id(chainId) {
+        return this._query(['centrifugeId', chainId], () => this._protocolAddresses(chainId).pipe(switchMap(({ messageDispatcher }) => {
+            return this.getClient(chainId).readContract({
+                address: messageDispatcher,
+                abi: ABI.MessageDispatcher,
+                functionName: 'localCentrifugeId',
+            });
+        })));
     }
     /**
-     * Get the metadata for an ERC20 token
+     * Get the existing pools on the different chains.
+     */
+    pools() {
+        return this._queryIndexer(`{
+        pools {
+          items {
+            id
+            blockchain {
+              id
+            }
+          }
+        }
+      }`, {}, (data) => {
+            return data.pools.items.map((pool) => {
+                const poolId = new PoolId(pool.id);
+                return new Pool(this, poolId.toString(), Number(pool.blockchain.id));
+            });
+        });
+    }
+    pool(id) {
+        return this._query(null, () => this.pools().pipe(map((pools) => {
+            const pool = pools.find((pool) => pool.id.equals(id));
+            if (!pool)
+                throw new Error(`Pool with id ${id} not found`);
+            return pool;
+        })));
+    }
+    /**
+     * Get the metadata for an ERC20 or ERC6909 token
      * @param address - The token address
      * @param chainId - The chain ID
      */
-    currency(address, chainId) {
+    currency(address, chainId, tokenId = 0n) {
         const curAddress = address.toLowerCase();
-        const cid = chainId ?? this.config.defaultChain;
-        return this._query(['currency', curAddress, cid], () => defer(async () => {
-            const contract = getContract({
-                address: curAddress,
-                abi: ABI.Currency,
-                client: this.getClient(cid),
-            });
-            const [decimals, name, symbol, supportsPermit] = await Promise.all([
-                contract.read.decimals(),
-                contract.read.name(),
-                contract.read.symbol(),
-                contract.read.PERMIT_TYPEHASH()
-                    .then((hash) => hash === PERMIT_TYPEHASH)
-                    .catch(() => false),
-            ]);
+        return this._query(['currency', curAddress, chainId, tokenId], () => defer(async () => {
+            let decimals, name, symbol, supportsPermit;
+            if (tokenId) {
+                const contract = getContract({
+                    address: curAddress,
+                    abi: ABI.ERC6909,
+                    client: this.getClient(chainId),
+                });
+                [decimals, name, symbol] = await Promise.all([
+                    contract.read.decimals([tokenId]),
+                    contract.read.name([tokenId]),
+                    contract.read.symbol([tokenId]),
+                ]);
+                supportsPermit = false;
+            }
+            else {
+                const contract = getContract({
+                    address: curAddress,
+                    abi: ABI.Currency,
+                    client: this.getClient(chainId),
+                });
+                [decimals, name, symbol, supportsPermit] = await Promise.all([
+                    contract.read.decimals(),
+                    contract.read.name(),
+                    contract.read.symbol(),
+                    contract.read
+                        .PERMIT_TYPEHASH()
+                        .then((hash) => hash === PERMIT_TYPEHASH)
+                        .catch(() => false),
+                ]);
+            }
             return {
                 address: curAddress,
+                tokenId,
                 decimals,
                 name,
                 symbol,
-                chainId: cid,
+                chainId,
                 supportsPermit,
             };
         }));
     }
+    /**
+     * Get the asset currency details for a given asset ID
+     * @param assetId - The asset ID to query
+     */
+    assetCurrency(assetId) {
+        return this._query(['asset', assetId.toString()], () => this._idToChain(assetId.centrifugeId).pipe(switchMap((chainId) => this._protocolAddresses(chainId).pipe(map(({ spoke }) => ({ chainId, spoke })))), switchMap(async ({ spoke, chainId }) => {
+            const [assetAddress, tokenId] = await this.getClient(chainId).readContract({
+                address: spoke,
+                abi: ABI.Spoke,
+                functionName: 'idToAsset',
+                args: [assetId.raw],
+            });
+            return this.currency(assetAddress, chainId, tokenId);
+        })));
+    }
+    investor(address) {
+        return this._query(null, () => of(new Investor(this, address)));
+    }
     /**
      * Get the balance of an ERC20 token for a given owner.
      * @param currency - The token address
@@ -122,16 +327,19 @@ export class Centrifuge {
      */
     balance(currency, owner, chainId) {
         const address = owner.toLowerCase();
-        const cid = chainId ?? this.config.defaultChain;
-        return this._query(['balance', currency, owner, cid], () => {
-            return this.currency(currency, cid).pipe(switchMap((currencyMeta) => defer(() => this.getClient(cid)
-                .readContract({
-                address: currency,
-                abi: ABI.Currency,
-                functionName: 'balanceOf',
-                args: [address],
-            })
-                .then((val) => new Currency(val, currencyMeta.decimals))).pipe(repeatOnEvents(this, {
+        return this._query(['balance', currency, owner, chainId], () => {
+            return this.currency(currency, chainId).pipe(switchMap((currencyMeta) => defer(async () => {
+                const val = await this.getClient(chainId).readContract({
+                    address: currency,
+                    abi: ABI.Currency,
+                    functionName: 'balanceOf',
+                    args: [address],
+                });
+                return {
+                    balance: new Balance(val, currencyMeta.decimals),
+                    currency: currencyMeta,
+                };
+            }).pipe(repeatOnEvents(this, {
                 address: currency,
                 abi: ABI.Currency,
                 eventName: 'Transfer',
@@ -140,18 +348,149 @@ export class Centrifuge {
                         return event.args.from?.toLowerCase() === address || event.args.to?.toLowerCase() === address;
                     });
                 },
-            }, cid))));
+            }, chainId))));
         });
     }
+    /**
+     * Get the assets that exist on a given spoke chain that have been registered on a given hub chain.
+     * @param spokeChainId - The chain ID where the assets exist
+     * @param hubChainId - The chain ID where the assets should optionally be registered
+     */
+    assets(spokeChainId, hubChainId = spokeChainId) {
+        return this._query(null, () => combineLatest([this.id(spokeChainId), this.id(hubChainId)]).pipe(switchMap(([spokeCentId, hubCentId]) => this._queryIndexer(`query ($hubCentId: String!) {
+              assetRegistrations(where: { centrifugeId: $hubCentId, decimals_gt: 0 }) {
+                items {
+                  assetId
+                  name
+                  symbol
+                  decimals
+                  asset {
+                    centrifugeId
+                    address
+                  }
+                }
+              }
+            }`, { hubCentId: String(hubCentId) }, (data) => {
+            return data.assetRegistrations.items
+                .filter((assetReg) => assetReg.asset && Number(assetReg.asset.centrifugeId) === spokeCentId)
+                .map((assetReg) => {
+                return {
+                    id: new AssetId(assetReg.assetId),
+                    address: assetReg.asset.address,
+                    name: assetReg.name,
+                    symbol: assetReg.symbol,
+                    decimals: assetReg.decimals,
+                };
+            });
+        }))));
+    }
+    /**
+     * Get the valuation addresses that can be used for holdings.
+     */
+    valuations(chainId) {
+        return this._query(null, () => this._protocolAddresses(chainId).pipe(map(({ identityValuation }) => {
+            return {
+                identityValuation,
+            };
+        })));
+    }
+    /**
+     * Get the restriction hook addresses that can be used for share tokens.
+     */
+    restrictionHooks(chainId) {
+        return this._query(null, () => this._protocolAddresses(chainId).pipe(map(({ freezeOnlyHook, redemptionRestrictionsHook, fullRestrictionsHook /* freelyTransferableHook */ }) => {
+            return {
+                freezeOnlyHook,
+                redemptionRestrictionsHook,
+                fullRestrictionsHook,
+            };
+        })));
+    }
+    /**
+     * Register an asset
+     * @param originChainId - The chain ID where the asset exists
+     * @param registerOnChainId - The chain ID where the asset should be registered
+     * @param assetAddress - The address of the asset to register
+     * @param tokenId - Optional token ID for ERC6909 assets
+     */
+    registerAsset(originChainId, registerOnChainId, assetAddress, tokenId = 0) {
+        const self = this;
+        return this._transact(async function* ({ walletClient, publicClient }) {
+            const [addresses, id, estimate] = await Promise.all([
+                self._protocolAddresses(originChainId),
+                self.id(registerOnChainId),
+                self._estimate(originChainId, { chainId: registerOnChainId }, MessageType.RegisterAsset),
+            ]);
+            yield* doTransaction('Register asset', publicClient, () => walletClient.writeContract({
+                address: addresses.spoke,
+                abi: ABI.Spoke,
+                functionName: 'registerAsset',
+                args: [id, assetAddress, BigInt(tokenId)],
+                value: estimate,
+            }));
+        }, originChainId);
+    }
+    /**
+     * Get the decimals of asset on the Hub side
+     * @internal
+     */
+    _assetDecimals(assetId, chainId) {
+        return this._query(['assetDecimals', assetId.toString()], () => this._protocolAddresses(chainId).pipe(switchMap(({ hubRegistry }) => this.getClient(chainId).readContract({
+            address: hubRegistry,
+            // Use inline ABI because of function overload
+            abi: parseAbi(['function decimals(uint128) view returns (uint8)']),
+            functionName: 'decimals',
+            args: [assetId.raw],
+        }))));
+    }
+    /**
+     * Get the allowance of an ERC20 or ERC6909 token.
+     * which is the contract that moves funds into the vault on behalf of the investor.
+     * @param owner - The address of the owner
+     * @param spender - The address of the spender
+     * @param chainId - The chain ID where the asset is located
+     * @param asset - The address of the asset
+     * @param tokenId - Optional token ID for ERC6909 assets
+     * @internal
+     */
+    _allowance(owner, spender, chainId, asset, tokenId) {
+        return this._query(['allowance', owner.toLowerCase(), spender.toLowerCase(), asset.toLowerCase(), chainId, tokenId], () => defer(async () => {
+            const client = this.getClient(chainId);
+            if (tokenId) {
+                return client.readContract({
+                    address: asset,
+                    abi: ABI.ERC6909,
+                    functionName: 'allowance',
+                    args: [owner, spender, tokenId],
+                });
+            }
+            return client.readContract({
+                address: asset,
+                abi: ABI.Currency,
+                functionName: 'allowance',
+                args: [owner, spender],
+            });
+        }).pipe(repeatOnEvents(this, {
+            address: asset,
+            abi: [ABI.Currency, ABI.ERC6909],
+            eventName: ['Approval', 'Transfer'],
+            filter: (events) => {
+                return events.some((event) => {
+                    return (event.args.owner?.toLowerCase() === owner.toLowerCase() ||
+                        event.args.spender?.toLowerCase() === owner.toLowerCase() ||
+                        event.args.from?.toLowerCase() === owner.toLowerCase());
+                });
+            },
+        }, chainId)));
+    }
     /**
      * Returns an observable of all events on a given chain.
      * @internal
      */
     _events(chainId) {
-        const cid = chainId ?? this.config.defaultChain;
-        return this._query(['events', cid], () => using(() => {
+        return this._query(['events', chainId], () => using(() => {
             const subject = new Subject();
-            const unwatch = this.getClient(cid).watchEvent({
+            const unwatch = this.getClient(chainId).watchEvent({
                 onLogs: (logs) => subject.next(logs),
             });
             return {
@@ -199,30 +538,26 @@ export class Centrifuge {
         });
     }
     _queryIndexer(query, variables, postProcess) {
-        return this._query([query, variables], () => this._getIndexerObservable(query, variables).pipe(map(postProcess ?? identity)), {
-            valueCacheTime: 120,
-        });
-    }
-    /**
-     * @internal
-     */
-    _getIPFSObservable(hash) {
-        return fromFetch(`${this.config.ipfsUrl}/ipfs/${hash}`, {
-            method: 'GET',
-            selector: async (res) => {
-                if (!res.ok) {
-                    console.warn(`Failed to fetch IPFS data: ${res.statusText}`);
-                }
-                const data = await res.json();
-                return data;
-            },
-        });
+        return this._query([query, variables], () => 
+        // If subscribed, refetch every 2 minutes
+        timer(0, 120_000).pipe(switchMap(() => this._getIndexerObservable(query, variables).pipe(map(postProcess ?? identity)))));
     }
     /**
      * @internal
      */
     _queryIPFS(hash) {
-        return this._query([hash], () => this._getIPFSObservable(hash));
+        return this._query([hash], () => defer(async () => {
+            const url = getUrlFromHash(hash, this.#config.ipfsUrl);
+            if (!url) {
+                throw new Error(`Invalid IPFS hash: ${hash}`);
+            }
+            const res = await fetch(url);
+            if (!res.ok) {
+                throw new Error(`Error fetching IPFS hash ${hash}: ${res.statusText}`);
+            }
+            const data = (await res.json());
+            return data;
+        }));
     }
     #memoized = new Map();
     #memoizeWith(keys, callback) {
@@ -289,10 +624,9 @@ export class Centrifuge {
      * const chainId = 1
      *
      * // Wrap an observable that only emits one value and then completes
-     * //
      * const query = this._query(['balance', address, tUSD, chainId], () => {
      *   return defer(() => fetchBalance(address, tUSD, chainId))
-     * }, { valueCacheTime: 60 })
+     * }, { valueCacheTime: 60_000 })
      *
      * // Logs the current balance and updated balances whenever a new
      * const obs1 = query.subscribe(balance => console.log(balance))
@@ -316,14 +650,17 @@ export class Centrifuge {
      * @internal
      */
     _query(keys, observableCallback, options) {
+        const cache = options?.cache !== false && this.#config.cache !== false;
+        const obsCacheTime = options?.observableCacheTime ?? this.#config.pollingInterval ?? 4000;
         function get() {
             const sharedSubject = new Subject();
             function createShared() {
                 const $shared = observableCallback().pipe(keys
                     ? shareReplayWithDelayedReset({
-                        bufferSize: (options?.cache ?? true) ? 1 : 0,
-                        resetDelay: (options?.cache === false ? 0 : (options?.observableCacheTime ?? 60)) * 1000,
-                        windowTime: (options?.valueCacheTime ?? Infinity) * 1000,
+                        bufferSize: cache ? 1 : 0,
+                        resetDelay: cache ? obsCacheTime : 0,
+                        // TODO: Fix valueCacheTime to not cause an infinite loop when the value is expired.
+                        // windowTime: options?.valueCacheTime ?? Infinity,
                     })
                     : map((val) => val));
                 sharedSubject.next($shared);
@@ -343,50 +680,9 @@ export class Centrifuge {
         return keys ? this.#memoizeWith(keys, get) : get();
     }
     /**
-     * Executes a transaction on a given chain.
-     * When subscribed to, it emits status updates as it progresses.
-     * When awaited, it returns the final confirmed if successful.
-     * Will additionally prompt the user to switch chains if they're not on the correct chain.
-     *
-     * @example
-     * ```ts
-     * const tx = this._transact(
-     *   'Transfer',
-     *   ({ walletClient }) =>
-     *     walletClient.writeContract({
-     *       address: '0xabc...123',
-     *       abi: ABI.Currency,
-     *       functionName: 'transfer',
-     *       args: ['0xdef...456', 1000000n],
-     *     }),
-     *   1
-     * )
-     * tx.subscribe(status => console.log(status))
-     *
-     * // Results in something like the following values being emitted (assuming the user wasn't connected to mainnet):
-     * // { type: 'SwitchingChain', chainId: 1 }
-     * // { type: 'SigningTransaction', title: 'Transfer' }
-     * // { type: 'TransactionPending', title: 'Transfer', hash: '0x123...abc' }
-     * // { type: 'TransactionConfirmed', title: 'Transfer', hash: '0x123...abc', receipt: { ... } }
-     * ```
-     *
-     * ```ts
-     * const finalResult = await this._transact(...)
-     * console.log(finalResult) // { type: 'TransactionConfirmed', title: 'Transfer', hash: '0x123...abc', receipt: { ... } }
-     * ```
-     *
-     * @internal
-     */
-    _transact(title, transactionCallback, chainId) {
-        return this._transactSequence(async function* (params) {
-            const transaction = transactionCallback(params);
-            yield* doTransaction(title, params.publicClient, () => transaction);
-        }, chainId);
-    }
-    /**
-     * Executes a sequence of transactions on a given chain.
+     * Executes one or more transactions on a given chain.
      * When subscribed to, it emits status updates as it progresses.
-     * When awaited, it returns the final confirmed if successful.
+     * When awaited, it returns the final confirmed result if successful.
      * Will additionally prompt the user to switch chains if they're not on the correct chain.
      *
      * @example
@@ -413,41 +709,53 @@ export class Centrifuge {
      * // { type: 'SigningTransaction', title: 'Invest' }
      * // { type: 'TransactionPending', title: 'Invest', hash: '0x123...abc' }
      * // { type: 'TransactionConfirmed', title: 'Invest', hash: '0x123...abc', receipt: { ... } }
+     * ```
      *
      * @internal
      */
-    _transactSequence(transactionCallback, chainId) {
-        const targetChainId = chainId ?? this.config.defaultChain;
+    _transact(transactionCallback, chainId) {
         const self = this;
         async function* transact() {
+            let isBatching = false;
+            if (self.#isBatching.has($tx)) {
+                isBatching = true;
+            }
             const { signer } = self;
             if (!signer)
                 throw new Error('Signer not set');
-            const publicClient = self.getClient(targetChainId);
-            const chain = self.getChainConfig(targetChainId);
-            const bareWalletClient = isLocalAccount(signer)
-                ? createWalletClient({ account: signer, chain, transport: http(self.#config.rpcUrls?.[chain.id]) })
+            const publicClient = self.getClient(chainId);
+            const chain = self.getChainConfig(chainId);
+            let walletClient = isLocalAccount(signer)
+                ? createWalletClient({
+                    account: signer,
+                    chain,
+                    transport: http(),
+                })
                 : createWalletClient({ transport: custom(signer) });
-            const [address] = await bareWalletClient.getAddresses();
+            const [address] = await walletClient.getAddresses();
             if (!address)
                 throw new Error('No account selected');
-            const selectedChain = await bareWalletClient.getChainId();
-            if (selectedChain !== targetChainId) {
-                yield { type: 'SwitchingChain', chainId: targetChainId };
-                await bareWalletClient.switchChain({ id: targetChainId });
+            if (!isBatching) {
+                const selectedChain = await walletClient.getChainId();
+                if (selectedChain !== chainId) {
+                    yield { type: 'SwitchingChain', chainId };
+                    await walletClient.switchChain({ id: chainId });
+                }
             }
             // Re-create the wallet client with the correct chain and account
             // Saves having to pass `account` and `chain` to every `writeContract` call
-            const walletClient = isLocalAccount(signer)
-                ? bareWalletClient
+            walletClient = isLocalAccount(signer)
+                ? walletClient
                 : createWalletClient({ account: address, chain, transport: custom(signer) });
             const transaction = transactionCallback({
+                isBatching,
                 signingAddress: address,
                 chain,
-                chainId: targetChainId,
+                chainId,
                 publicClient,
                 walletClient,
                 signer,
+                root: self,
             });
             if (Symbol.asyncIterator in transaction) {
                 yield* transaction;
@@ -460,7 +768,197 @@ export class Centrifuge {
             }
         }
         const $tx = defer(transact).pipe(mergeMap((d) => (isObservable(d) ? d : of(d))));
-        return makeThenable($tx, true);
+        makeThenable($tx, true);
+        Object.assign($tx, {
+            chainId,
+        });
+        return $tx;
+    }
+    /**
+     * Batch multiple transactions together into a single transaction.
+     * It's not exposed, because it is somewhat limited and requires knowledge of internals.
+     * It only works when there's only a single transaction being done in the method.
+     * It only works for methods that wrap the transaction in `wrapTransaction`.
+     * It only works when the transactions are executed on the same contract on the same chain,
+     * and that contract supports multicall
+     * @internal
+     */
+    _experimental_batch(title, transactions) {
+        const chainIds = [...new Set(transactions.map((tx) => tx.chainId))];
+        if (chainIds.length !== 1) {
+            throw new Error(`Cannot batch transactions on different chains: ${chainIds.join(', ')}`);
+        }
+        for (const tx of transactions) {
+            this.#isBatching.add(tx);
+        }
+        return this._transact((ctx) => combineLatest(transactions.map((tx) => tx.pipe(first()))).pipe(switchMap(async function* (batches_) {
+            const batches = batches_;
+            if (!batches.every((b) => b.data && b.contract)) {
+                throw new Error('Not all transactions can be batched');
+            }
+            const value = batches.reduce((acc, b) => acc + (b.value ?? 0n), 0n);
+            const data = batches.map((b) => b.data).flat();
+            const messages = batches.reduce((acc, b) => {
+                if (b.messages) {
+                    Object.entries(b.messages).forEach(([cid, types]) => {
+                        const chainId = Number(cid);
+                        if (!acc[chainId])
+                            acc[chainId] = [];
+                        acc[chainId].push(...types);
+                    });
+                }
+                return acc;
+            }, {});
+            const contracts = [...new Set(batches.map((b) => b.contract))];
+            if (contracts.length !== 1) {
+                throw new Error(`Cannot batch transactions to different contracts: ${contracts.join(', ')}`);
+            }
+            yield* wrapTransaction(title, ctx, { data, value, contract: contracts[0], messages });
+        })), chainIds[0]);
+    }
+    /** @internal */
+    _protocolAddresses(chainId) {
+        return this._query(null, () => this._deployments().pipe(map((data) => {
+            if (!this.chains.includes(chainId)) {
+                throw new Error(`Chain ID "${chainId}" not supported`);
+            }
+            const deployment = data.deployments.items.find((d) => Number(d.chainId) === chainId);
+            if (!deployment) {
+                throw new Error(`No protocol contracts found for chain ID "${chainId}"`);
+            }
+            return deployment;
+        })));
+    }
+    /** @internal */
+    _getQuote(valuationAddress, baseAmount, baseAssetId, quoteAssetId, chainId) {
+        return this._query(['getQuote', baseAmount, baseAssetId.toString(), quoteAssetId.toString()], () => timer(0, 60_000).pipe(switchMap(() => this._protocolAddresses(chainId)), switchMap(({ hubRegistry }) => defer(async () => {
+            const [quote, quoteDecimals] = await Promise.all([
+                this.getClient(chainId).readContract({
+                    address: valuationAddress,
+                    abi: ABI.Valuation,
+                    functionName: 'getQuote',
+                    args: [baseAmount.toBigInt(), baseAssetId.raw, quoteAssetId.raw],
+                }),
+                this.getClient(chainId).readContract({
+                    address: hubRegistry,
+                    // Use inline ABI because of function overload
+                    abi: parseAbi(['function decimals(uint256) view returns (uint8)']),
+                    functionName: 'decimals',
+                    args: [quoteAssetId.raw],
+                }),
+            ]);
+            return new Balance(quote, quoteDecimals);
+        }))));
+    }
+    /**
+     * Estimates the gas cost needed to bridge the message from one chain to another,
+     * that results from a transaction
+     * @internal
+     */
+    _estimate(fromChain, to, messageType) {
+        return this._query(['estimate', fromChain, to, messageType], () => this._protocolAddresses(fromChain).pipe(switchMap(({ multiAdapter, gasService }) => {
+            const types = Array.isArray(messageType) ? messageType : [messageType];
+            return combineLatest([
+                'chainId' in to ? this.id(to.chainId) : of(to.centId),
+                ...types.map((typeAndMaybeSubtype) => {
+                    const type = typeof typeAndMaybeSubtype === 'number' ? typeAndMaybeSubtype : typeAndMaybeSubtype.type;
+                    const subtype = typeof typeAndMaybeSubtype === 'number' ? undefined : typeAndMaybeSubtype.subtype;
+                    const data = emptyMessage(type, subtype);
+                    return this.getClient(fromChain).readContract({
+                        address: gasService,
+                        abi: ABI.GasService,
+                        functionName: 'messageGasLimit',
+                        args: [0, data],
+                    });
+                }),
+            ]).pipe(switchMap(async ([toCentId, ...gasLimits]) => {
+                const estimate = await this.getClient(fromChain).readContract({
+                    address: multiAdapter,
+                    abi: ABI.MultiAdapter,
+                    functionName: 'estimate',
+                    args: [toCentId, '0x0', gasLimits.reduce((acc, val) => acc + val, 0n)],
+                });
+                return (estimate * 3n) / 2n; // Add 50% buffer to the estimate
+            }));
+        })));
+    }
+    /** @internal */
+    _maxBatchGasLimit(chainId) {
+        return this._query(['maxBatchGasLimit', chainId], () => this._protocolAddresses(chainId).pipe(switchMap(async ({ gasService }) => {
+            try {
+                // `batchGasLimit` was renamed to `maxBatchGasLimit`, support both for backwards compatibility,
+                // until all chains are updated
+                return await this.getClient(chainId).readContract({
+                    address: gasService,
+                    abi: ABI.GasService,
+                    functionName: 'maxBatchGasLimit',
+                    args: [0],
+                });
+            }
+            catch {
+                return await this.getClient(chainId).readContract({
+                    address: gasService,
+                    abi: ABI.GasService,
+                    functionName: 'batchGasLimit',
+                    args: [0],
+                });
+            }
+        })));
+    }
+    /** @internal */
+    _idToChain(centrifugeId) {
+        return this._query(null, () => this._deployments().pipe(map((data) => {
+            const item = data.blockchains.items.find((b) => Number(b.centrifugeId) === centrifugeId);
+            if (!item)
+                throw new Error(`Chain with Centrifuge ID "${centrifugeId}" not found`);
+            return Number(item.id);
+        })));
+    }
+    /** @internal */
+    _deployments() {
+        return this._query(['deployments'], () => this._getIndexerObservable(`{
+            blockchains {
+              items {
+                centrifugeId
+                id
+              }
+            }
+            deployments { 
+              items {
+                accounting
+                asyncRequestManager
+                asyncVaultFactory
+                axelarAdapter
+                balanceSheet
+                centrifugeId
+                chainId
+                freezeOnlyHook
+                fullRestrictionsHook
+                gasService
+                gateway
+                globalEscrow
+                guardian
+                holdings
+                hub
+                hubRegistry
+                identityValuation
+                messageDispatcher
+                messageProcessor
+                multiAdapter
+                poolEscrowFactory
+                redemptionRestrictionsHook
+                root
+                routerEscrow
+                shareClassManager
+                spoke
+                syncDepositVaultFactory
+                syncManager
+                wormholeAdapter
+                vaultRouter
+                tokenFactory
+              }
+            }
+          }`));
     }
 }
 //# sourceMappingURL=Centrifuge.js.map