@centrifuge/sdk 0.55.2 → 1.0.0

package/dist/Centrifuge.js

@@ -1,4 +1,4 @@
-import { combineLatest, defer, filter, first, identity, isObservable, map, mergeMap, of, switchMap, timer, Observable, shareReplay, } from 'rxjs';
+import { combineLatest, defer, filter, first, identity, isObservable, map, mergeMap, Observable, of, shareReplay, switchMap, timer, } from 'rxjs';
 import { fromFetch } from 'rxjs/fetch';
 import { createPublicClient, createWalletClient, custom, encodeFunctionData, fallback, getContract, http, keccak256, parseAbi, toHex, } from 'viem';
 import { ABI } from './abi/index.js';
@@ -8,7 +8,7 @@ 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 { generateShareClassSalt, 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';
@@ -18,12 +18,12 @@ const PINNING_API_DEMO = 'https://europe-central2-peak-vista-185616.cloudfunctio
 const envConfig = {
     mainnet: {
         indexerUrl: 'https://api.centrifuge.io',
-        ipfsUrl: 'https://centrifuge.mypinata.cloud',
+        ipfsUrl: 'https://ipfs.centrifuge.io',
         ...createPinning(PINNING_API_DEMO),
     },
     testnet: {
         indexerUrl: 'https://api-v3-hitz.marble.live/graphql',
-        ipfsUrl: 'https://centrifuge.mypinata.cloud',
+        ipfsUrl: 'https://ipfs.centrifuge.io',
         ...createPinning(PINNING_API_DEMO),
     },
 };
@@ -37,17 +37,22 @@ export class Centrifuge {
         return this.#config;
     }
     #clients = new Map();
-    getClient(chainId) {
-        const client = this.#clients.get(chainId);
-        if (!client)
-            throw new Error(`No client found for chain ID "${chainId}"`);
-        return client;
+    getClient(centrifugeId) {
+        return this._query(['client', centrifugeId], () => this._idToChain(centrifugeId).pipe(map((chainId) => {
+            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).chain;
+    get chainConfigs() {
+        return [...this.#clients.values()].map((client) => client.chain);
+    }
+    getChainConfig(centrifugeId) {
+        return this._query(['chainConfig', centrifugeId], () => this.getClient(centrifugeId).pipe(map((client) => client.chain)));
     }
     #signer = null;
     setSigner(signer) {
@@ -95,11 +100,11 @@ export class Centrifuge {
      * @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) {
+    createPool(metadataInput, currencyCode = 840, centrifugeId, counter) {
         const self = this;
         return this._transact(async function* (ctx) {
-            const [addresses, id] = await Promise.all([self._protocolAddresses(chainId), self.id(chainId)]);
-            const poolId = PoolId.from(id, counter ?? randomUint(48));
+            const addresses = await self._protocolAddresses(centrifugeId);
+            const poolId = PoolId.from(centrifugeId, counter ?? randomUint(48));
             const createPoolData = encodeFunctionData({
                 abi: ABI.Hub,
                 functionName: 'createPool',
@@ -177,7 +182,7 @@ export class Centrifuge {
                     poolId.raw,
                     sc.tokenName,
                     sc.symbolName,
-                    sc.salt?.startsWith('0x') ? sc.salt : toHex(sc.salt ?? randomUint(256), { size: 32 }),
+                    sc.salt?.startsWith('0x') ? sc.salt : generateShareClassSalt(poolId.raw),
                 ],
             }));
             const accountIsDebitNormal = new Map();
@@ -203,7 +208,7 @@ export class Centrifuge {
             const createAccountsData = accountNumbers.map((account) => encodeFunctionData({
                 abi: ABI.Hub,
                 functionName: 'createAccount',
-                args: [poolId.raw, account, accountIsDebitNormal.get(account)],
+                args: [poolId.raw, BigInt(account), accountIsDebitNormal.get(account)],
             }));
             yield* doTransaction('Create pool', ctx, () => {
                 return ctx.walletClient.writeContract({
@@ -213,16 +218,10 @@ export class Centrifuge {
                     args: [[createPoolData, setMetadataData, ...addScData, ...createAccountsData]],
                 });
             });
-        }, chainId);
+        }, centrifugeId);
     }
     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',
-            });
-        })));
+        return this._chainToId(chainId);
     }
     /**
      * Get information about all supported blockchains from the indexer.
@@ -233,6 +232,7 @@ export class Centrifuge {
           items {
             explorer
             chainId
+            centrifugeId
             icon
             name
             network
@@ -242,6 +242,7 @@ export class Centrifuge {
             return data.blockchains.items.map((blockchain) => ({
                 explorer: blockchain.explorer,
                 chainId: Number(blockchain.chainId),
+                centrifugeId: Number(blockchain.centrifugeId),
                 icon: blockchain.icon,
                 name: blockchain.name,
                 network: blockchain.network,
@@ -264,7 +265,7 @@ export class Centrifuge {
       }`, {}, (data) => {
             return data.pools.items.map((pool) => {
                 const poolId = new PoolId(pool.id);
-                return new Pool(this, poolId.toString(), Number(pool.blockchain.id));
+                return new Pool(this, poolId.toString());
             });
         });
     }
@@ -281,15 +282,15 @@ export class Centrifuge {
      * @param address - The token address
      * @param chainId - The chain ID
      */
-    currency(address, chainId, tokenId = 0n) {
+    currency(address, centrifugeId, tokenId = 0n) {
         const curAddress = address.toLowerCase();
-        return this._query(['currency', curAddress, chainId, tokenId], () => defer(async () => {
+        return this._query(['currency', curAddress, centrifugeId, tokenId], () => combineLatest([this.getClient(centrifugeId), this._idToChain(centrifugeId)]).pipe(switchMap(([client, chainId]) => defer(async () => {
             let decimals, name, symbol, supportsPermit;
             if (tokenId) {
                 const contract = getContract({
                     address: curAddress,
                     abi: ABI.ERC6909,
-                    client: this.getClient(chainId),
+                    client,
                 });
                 [decimals, name, symbol] = await Promise.all([
                     contract.read.decimals([tokenId]),
@@ -302,7 +303,7 @@ export class Centrifuge {
                 const contract = getContract({
                     address: curAddress,
                     abi: ABI.Currency,
-                    client: this.getClient(chainId),
+                    client,
                 });
                 [decimals, name, symbol, supportsPermit] = await Promise.all([
                     contract.read.decimals(),
@@ -321,23 +322,24 @@ export class Centrifuge {
                 name,
                 symbol,
                 chainId,
+                centrifugeId,
                 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({
+        return this._query(['asset', assetId.toString()], () => combineLatest([this.getClient(assetId.centrifugeId), this._protocolAddresses(assetId.centrifugeId)]).pipe(switchMap(async ([client, { spoke }]) => {
+            const [assetAddress, tokenId] = await client.readContract({
                 address: spoke,
                 abi: ABI.Spoke,
                 functionName: 'idToAsset',
                 args: [assetId.raw],
             });
-            return this.currency(assetAddress, chainId, tokenId);
+            return this.currency(assetAddress, assetId.centrifugeId, tokenId);
         })));
     }
     investor(address) {
@@ -349,11 +351,11 @@ export class Centrifuge {
      * @param owner - The owner address
      * @param chainId - The chain ID
      */
-    balance(currency, owner, chainId) {
+    balance(currency, owner, centrifugeId) {
         const address = owner.toLowerCase();
-        return this._query(['balance', currency, owner, chainId], () => {
-            return this.currency(currency, chainId).pipe(switchMap((currencyMeta) => defer(async () => {
-                const val = await this.getClient(chainId).readContract({
+        return this._query(['balance', currency, owner, centrifugeId], () => {
+            return combineLatest([this.currency(currency, centrifugeId), this.getClient(centrifugeId)]).pipe(switchMap(([currencyMeta, client]) => defer(async () => {
+                const val = await client.readContract({
                     address: currency,
                     abi: ABI.Currency,
                     functionName: 'balanceOf',
@@ -371,16 +373,16 @@ export class Centrifuge {
                         return event.args.from?.toLowerCase() === address || event.args.to?.toLowerCase() === address;
                     });
                 },
-            }, chainId))));
+            }, centrifugeId))));
         });
     }
     /**
      * 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
+     * @param spokeCentrifugeId - The Centrifuge ID where the assets exist
+     * @param hubCentrifugeId - The Centrifuge ID where the assets should optionally be registered
      */
-    assets(spokeChainId, hubChainId = spokeChainId) {
-        return this._query(['assets', spokeChainId, hubChainId], () => combineLatest([this.id(spokeChainId), this.id(hubChainId)]).pipe(switchMap(([spokeCentId, hubCentId]) => this._queryIndexer(`query ($hubCentId: String!) {
+    assets(spokeCentrifugeId, hubCentrifugeId = spokeCentrifugeId) {
+        return this._query(['assets', spokeCentrifugeId, hubCentrifugeId], () => this._queryIndexer(`query ($hubCentId: String!) {
               assetRegistrations(where: { centrifugeId: $hubCentId }, limit: 1000) {
                 items {
                   assetId
@@ -394,9 +396,9 @@ export class Centrifuge {
                   }
                 }
               }
-            }`, { hubCentId: String(hubCentId) }).pipe(map((data) => {
+            }`, { hubCentId: String(hubCentrifugeId) }).pipe(map((data) => {
             return data.assetRegistrations.items
-                .filter((assetReg) => assetReg.asset && Number(assetReg.asset.centrifugeId) === spokeCentId)
+                .filter((assetReg) => assetReg.asset && Number(assetReg.asset.centrifugeId) === spokeCentrifugeId)
                 .map((assetReg) => {
                 return {
                     id: new AssetId(assetReg.assetId),
@@ -407,13 +409,13 @@ export class Centrifuge {
                     tokenId: assetReg.asset.assetTokenId ? BigInt(assetReg.asset.assetTokenId) : undefined,
                 };
             });
-        })))));
+        })));
     }
     /**
      * Get the valuation addresses that can be used for holdings.
      */
-    valuations(chainId) {
-        return this._query(['valuations', chainId], () => this._protocolAddresses(chainId).pipe(map(({ identityValuation }) => {
+    valuations(centrifugeId) {
+        return this._query(['valuations', centrifugeId], () => this._protocolAddresses(centrifugeId).pipe(map(({ identityValuation }) => {
             return {
                 identityValuation,
             };
@@ -422,8 +424,8 @@ export class Centrifuge {
     /**
      * Get the restriction hook addresses that can be used for share tokens.
      */
-    restrictionHooks(chainId) {
-        return this._query(['restrictionHooks', chainId], () => this._protocolAddresses(chainId).pipe(map(({ freezeOnlyHook, redemptionRestrictionsHook, fullRestrictionsHook, freelyTransferableHook }) => {
+    restrictionHooks(centrifugeId) {
+        return this._query(['restrictionHooks', centrifugeId], () => this._protocolAddresses(centrifugeId).pipe(map(({ freezeOnlyHook, redemptionRestrictionsHook, fullRestrictionsHook, freelyTransferableHook }) => {
             return {
                 freezeOnlyHook,
                 redemptionRestrictionsHook,
@@ -432,47 +434,58 @@ export class Centrifuge {
             };
         })));
     }
+    /**
+     * Get the adapter addresses that are available for cross-chain communication.
+     */
+    adapters(centrifugeId) {
+        return this._query(['adapters', centrifugeId], () => this._protocolAddresses(centrifugeId).pipe(map(({ axelarAdapter, wormholeAdapter, layerZeroAdapter, chainlinkAdapter }) => {
+            return {
+                axelarAdapter,
+                wormholeAdapter,
+                layerZeroAdapter,
+                chainlinkAdapter,
+            };
+        })));
+    }
     /**
      * Register an asset
-     * @param originChainId - The chain ID where the asset exists
-     * @param registerOnChainId - The chain ID where the asset should be registered
+     * @param originCentrifugeId - The centrifuge ID where the asset exists
+     * @param registerOnCentrifugeId - The centrifuge 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) {
+    registerAsset(originCentrifugeId, registerOnCentrifugeId, assetAddress, tokenId = 0) {
         const self = this;
         return this._transact(async function* (ctx) {
-            const [addresses, id, estimate] = await Promise.all([
-                self._protocolAddresses(originChainId),
-                self.id(registerOnChainId),
-                self._estimate(originChainId, { chainId: registerOnChainId }, MessageType.RegisterAsset),
+            const [addresses, estimate] = await Promise.all([
+                self._protocolAddresses(originCentrifugeId),
+                self._estimate(originCentrifugeId, registerOnCentrifugeId, MessageType.RegisterAsset),
             ]);
             yield* doTransaction('Register asset', ctx, () => ctx.walletClient.writeContract({
                 address: addresses.spoke,
                 abi: ABI.Spoke,
                 functionName: 'registerAsset',
-                args: [id, assetAddress, BigInt(tokenId)],
+                args: [originCentrifugeId, assetAddress, BigInt(tokenId), ctx.signingAddress],
                 value: estimate,
             }));
-        }, originChainId);
+        }, originCentrifugeId);
     }
     /**
      * Repay an underpaid batch of messages on the Gateway
      */
-    repayBatch(fromChain, to, batch, extraPayment = 0n) {
+    repayBatch(fromCentrifugeId, toCentrifugeId, batch, extraPayment = 0n) {
         const self = this;
         return this._transact(async function* (ctx) {
-            const [addresses, toCentId] = await Promise.all([
-                self._protocolAddresses(fromChain),
-                'chainId' in to ? self.id(to.chainId) : to.centId,
+            const [addresses, client] = await Promise.all([
+                self._protocolAddresses(fromCentrifugeId),
+                self.getClient(fromCentrifugeId),
             ]);
-            const client = self.getClient(fromChain);
             const batchHash = keccak256(batch);
             const [counter, gasLimit] = await client.readContract({
                 address: addresses.gateway,
                 abi: ABI.Gateway,
                 functionName: 'underpaid',
-                args: [toCentId, batchHash],
+                args: [toCentrifugeId, batchHash],
             });
             if (counter === 0n) {
                 throw new Error(`Batch is not underpaid and can't be repaid. Batch hash: "${batchHash}"`);
@@ -481,38 +494,38 @@ export class Centrifuge {
                 address: addresses.multiAdapter,
                 abi: ABI.MultiAdapter,
                 functionName: 'estimate',
-                args: [toCentId, batch, gasLimit],
+                args: [toCentrifugeId, batch, gasLimit],
             });
             yield* doTransaction('Repay', ctx, () => ctx.walletClient.writeContract({
                 address: addresses.gateway,
                 abi: ABI.Gateway,
                 functionName: 'repay',
-                args: [toCentId, batch],
+                args: [toCentrifugeId, batch, ctx.signingAddress],
                 value: estimate + extraPayment,
             }));
-        }, fromChain);
+        }, fromCentrifugeId);
     }
     /**
      * Retry a failed message on the destination chain
      */
-    retryMessage(fromChain, toChain, message) {
+    retryMessage(fromCentrifugeId, toCentrifugeId, message) {
         const self = this;
         return this._transact(async function* (ctx) {
-            const [addresses, fromCentId] = await Promise.all([self._protocolAddresses(toChain), self.id(fromChain)]);
+            const addresses = await self._protocolAddresses(toCentrifugeId);
             yield* doTransaction('Retry', ctx, () => ctx.walletClient.writeContract({
                 address: addresses.gateway,
                 abi: ABI.Gateway,
                 functionName: 'retry',
-                args: [fromCentId, message],
+                args: [fromCentrifugeId, message],
             }));
-        }, toChain);
+        }, toCentrifugeId);
     }
     /**
      * 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({
+    _assetDecimals(assetId, centrifugeId) {
+        return this._query(['assetDecimals', assetId.toString()], () => combineLatest([this._protocolAddresses(centrifugeId), this.getClient(centrifugeId)]).pipe(switchMap(([{ hubRegistry }, client]) => client.readContract({
             address: hubRegistry,
             // Use inline ABI because of function overload
             abi: parseAbi(['function decimals(uint128) view returns (uint8)']),
@@ -525,14 +538,13 @@ export class Centrifuge {
      * 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 centrifugeId - The centrifuge 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);
+    _allowance(owner, spender, centrifugeId, asset, tokenId) {
+        return this._query(['allowance', owner.toLowerCase(), spender.toLowerCase(), asset.toLowerCase(), centrifugeId, tokenId], () => this.getClient(centrifugeId).pipe(switchMap((client) => defer(async () => {
             if (tokenId) {
                 return client.readContract({
                     address: asset,
@@ -557,27 +569,27 @@ export class Centrifuge {
                         event.args.from?.toLowerCase() === owner.toLowerCase());
                 });
             },
-        }, chainId)));
+        }, centrifugeId)))));
     }
     /**
      * Returns an observable of all events on a given chain.
      * @internal
      */
-    _events(chainId) {
-        return this._query(['events', chainId], () => new Observable((subscriber) => {
-            const unwatch = this.getClient(chainId).watchEvent({
+    _events(centrifugeId) {
+        return this._query(['events', centrifugeId], () => this.getClient(centrifugeId).pipe(switchMap((client) => new Observable((subscriber) => {
+            const unwatch = client.watchEvent({
                 onLogs: (logs) => subscriber.next(logs),
             });
             return unwatch;
-        }).pipe(filter((logs) => logs.length > 0), shareReplay({ bufferSize: 1, refCount: true }) // ensures only one watcher per chainId
+        })), filter((logs) => logs.length > 0), shareReplay({ bufferSize: 1, refCount: true }) // ensures only one watcher per centrifugeId
         ), { cache: true });
     }
     /**
      * Returns an observable of events on a given chain, filtered by name(s) and address(es).
      * @internal
      */
-    _filteredEvents(address, eventName, chainId) {
-        return this._events(chainId).pipe(map((logs) => {
+    _filteredEvents(address, eventName, centrifugeId) {
+        return this._events(centrifugeId).pipe(map((logs) => {
             return parseEventLogs({
                 address,
                 eventName,
@@ -649,11 +661,11 @@ export class Centrifuge {
      * ```ts
      * const address = '0xabc...123'
      * const tUSD = '0x456...def'
-     * const chainId = 1
+     * const centrifugeId = 1
      *
      * // Wrap an observable that continuously emits values
-     * const query = this._query(['balance', address, tUSD, chainId], () => {
-     *   return defer(() => fetchBalance(address, tUSD, chainId))
+     * const query = this._query(['balance', address, tUSD, centrifugeId], () => {
+     *   return defer(() => fetchBalance(address, tUSD, centrifugeId))
      *   .pipe(
      *     repeatOnEvents(
      *       this,
@@ -661,7 +673,7 @@ export class Centrifuge {
      *         address: tUSD,
      *         eventName: 'Transfer',
      *       },
-     *       chainId
+     *       centrifugeId
      *     )
      *   )
      * })
@@ -688,11 +700,11 @@ export class Centrifuge {
      * ```ts
      * const address = '0xabc...123'
      * const tUSD = '0x456...def'
-     * const chainId = 1
+     * const centrifugeId = 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))
+     * const query = this._query(['balance', address, tUSD, centrifugeId], () => {
+     *   return defer(() => fetchBalance(address, tUSD, centrifugeId))
      * }, { valueCacheTime: 60_000 })
      *
      * // Logs the current balance and updated balances whenever a new
@@ -762,7 +774,7 @@ export class Centrifuge {
      *
      * @internal
      */
-    _transact(transactionCallback, chainId) {
+    _transact(transactionCallback, centrifugeId) {
         const self = this;
         async function* transact() {
             let isBatching = false;
@@ -772,8 +784,11 @@ export class Centrifuge {
             const { signer } = self;
             if (!signer)
                 throw new Error('Signer not set');
-            const publicClient = self.getClient(chainId);
-            const chain = self.getChainConfig(chainId);
+            const [chainId, publicClient, chain] = await Promise.all([
+                self._idToChain(centrifugeId),
+                self.getClient(centrifugeId),
+                self.getChainConfig(centrifugeId),
+            ]);
             let walletClient = isLocalAccount(signer)
                 ? createWalletClient({
                     account: signer,
@@ -800,7 +815,7 @@ export class Centrifuge {
                 isBatching,
                 signingAddress: address,
                 chain,
-                chainId,
+                centrifugeId,
                 publicClient,
                 walletClient,
                 signer,
@@ -819,7 +834,7 @@ export class Centrifuge {
         const $tx = defer(transact).pipe(mergeMap((d) => (isObservable(d) ? d : of(d))));
         makeThenable($tx, true);
         Object.assign($tx, {
-            chainId,
+            centrifugeId,
         });
         return $tx;
     }
@@ -833,9 +848,9 @@ export class Centrifuge {
      * @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(', ')}`);
+        const centIds = [...new Set(transactions.map((tx) => tx.centrifugeId))];
+        if (centIds.length !== 1) {
+            throw new Error(`Cannot batch transactions on different networks. Found Centrifuge IDs: ${centIds.join(', ')}`);
         }
         for (const tx of transactions) {
             this.#isBatching.add(tx);
@@ -867,98 +882,50 @@ export class Centrifuge {
                 }
                 yield* wrapTransaction(title, ctx, { data, value, contract: contracts[0], messages });
             }));
-        }, chainIds[0]);
+        }, centIds[0]);
     }
     /** @internal */
-    _protocolAddresses(chainId) {
-        return this._query(['protocolAddresses', chainId], () => 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);
+    _protocolAddresses(centrifugeId) {
+        return this._query(['protocolAddresses', centrifugeId], () => this._deployments().pipe(map((data) => {
+            const deployment = data.deployments.items.find((d) => Number(d.centrifugeId) === centrifugeId);
             if (!deployment) {
-                throw new Error(`No protocol contracts found for chain ID "${chainId}"`);
+                throw new Error(`No protocol contracts found for centrifuge ID "${centrifugeId}"`);
             }
             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 }) => {
+    _estimate(fromCentrifugeId, toCentrifugeId, messageType) {
+        return this._query(['estimate', fromCentrifugeId, toCentrifugeId, messageType], () => combineLatest([this._protocolAddresses(fromCentrifugeId), this.getClient(fromCentrifugeId)]).pipe(switchMap(([{ multiAdapter, gasService }, client]) => {
             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({
+                    return client.readContract({
                         address: gasService,
                         abi: ABI.GasService,
-                        functionName: 'messageGasLimit',
-                        args: [0, data],
+                        functionName: 'messageOverallGasLimit',
+                        args: [toCentrifugeId, data],
                     });
                 }),
-            ]).pipe(switchMap(async ([toCentId, ...gasLimits]) => {
-                const estimate = await this.getClient(fromChain).readContract({
+            ]).pipe(switchMap(async ([...gasLimits]) => {
+                const estimate = await client.readContract({
                     address: multiAdapter,
                     abi: ABI.MultiAdapter,
                     functionName: 'estimate',
-                    args: [toCentId, '0x0', gasLimits.reduce((acc, val) => acc + val, 0n)],
+                    args: [toCentrifugeId, '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(['idToChain', centrifugeId], () => this._deployments().pipe(map((data) => {
             const item = data.blockchains.items.find((b) => Number(b.centrifugeId) === centrifugeId);
@@ -968,6 +935,15 @@ export class Centrifuge {
         })));
     }
     /** @internal */
+    _chainToId(chainId) {
+        return this._query(['chainToId', chainId], () => this._deployments().pipe(map((data) => {
+            const item = data.blockchains.items.find((b) => Number(b.id) === chainId);
+            if (!item)
+                throw new Error(`Blockchain with chain ID "${chainId}" not found`);
+            return Number(item.centrifugeId);
+        })));
+    }
+    /** @internal */
     _deployments() {
         return this._query(['deployments'], () => this._getIndexerObservable(`{
             blockchains {
@@ -985,6 +961,7 @@ export class Centrifuge {
                 balanceSheet
                 centrifugeId
                 chainId
+                chainlinkAdapter
                 freezeOnlyHook
                 fullRestrictionsHook
                 gasService
@@ -1003,7 +980,9 @@ export class Centrifuge {
                 root
                 routerEscrow
                 shareClassManager
+                batchRequestManager
                 spoke
+                vaultRegistry
                 syncDepositVaultFactory
                 syncManager
                 wormholeAdapter