@symmetry-hq/sdk 1.0.1

package/dist/src/states/basket.js

@@ -0,0 +1,479 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTokenMintsHash = computeTokenMintsHash;
+exports.addFieldsToBasket = addFieldsToBasket;
+exports.addLutsToBaskets = addLutsToBaskets;
+exports.fetchBasket = fetchBasket;
+exports.fetchBasketsMultiple = fetchBasketsMultiple;
+exports.fetchBaskets = fetchBaskets;
+exports.fetchBasketOracleAccountInfos = fetchBasketOracleAccountInfos;
+exports.loadBasketPrice = loadBasketPrice;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const crypto_1 = require("crypto");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../constants");
+const basket_1 = require("../layouts/basket");
+const oracle_1 = require("../layouts/oracle");
+const txUtils_1 = require("../txUtils");
+const oracle_2 = require("./oracles/oracle");
+const pythOracle_1 = require("./oracles/pythOracle");
+const raydiumClmmOracle_1 = require("./oracles/raydiumClmmOracle");
+const fraction_1 = require("../layouts/fraction");
+// export async function computeTokenMintsHash(mints: string[]): Promise<Buffer> {
+//     let hashBuffer = new Uint8Array(32)
+//     for (const mint of mints) {
+//       const mintBytes = new PublicKey(mint).toBytes()
+//       const combined = new Uint8Array(hashBuffer.length + mintBytes.length)
+//       combined.set(hashBuffer, 0)
+//       combined.set(mintBytes, hashBuffer.length)
+//       const hashArrayBuffer = await crypto.subtle.digest("SHA-256", combined)
+//       hashBuffer = new Uint8Array(hashArrayBuffer)
+//     }
+//     return Buffer.from(hashBuffer)
+// }
+function computeTokenMintsHash(mints) {
+    let hashBuffer = Buffer.alloc(32);
+    for (const mint of mints) {
+        hashBuffer = (0, crypto_1.createHash)('sha256').update(Buffer.concat([hashBuffer, new web3_js_1.PublicKey(mint).toBytes()])).digest();
+    }
+    return Array.from(hashBuffer);
+}
+function addFieldsToBasket(basket) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    let metadataSettings = basket.settings.metadata;
+    let metadata = {
+        symbol: Buffer.from(metadataSettings.symbol.slice(0, metadataSettings.symbolLength)).toString(),
+        name: Buffer.from(metadataSettings.name.slice(0, metadataSettings.nameLength)).toString(),
+        uri: Buffer.from(metadataSettings.uri.slice(0, metadataSettings.uriLength)).toString()
+    };
+    basket.composition = basket.composition.slice(0, basket.numTokens);
+    for (let i = 0; i < basket.numTokens; i++) {
+        let agg = basket.composition[i].oracleAggregator;
+        basket.composition[i].oracleAggregator.oracles = agg.oracles.slice(0, agg.numOracles);
+        for (let j = 0; j < agg.numOracles; j++) {
+            let lutIds = agg.oracles[j].accountsToLoadLutIds;
+            let lutIndices = agg.oracles[j].accountsToLoadLutIndices;
+            basket.composition[i].oracleAggregator.oracles[j].accountsToLoadLutIds =
+                lutIds.slice(0, agg.oracles[j].oracleSettings.numRequiredAccounts);
+            basket.composition[i].oracleAggregator.oracles[j].accountsToLoadLutIndices =
+                lutIndices.slice(0, agg.oracles[j].oracleSettings.numRequiredAccounts);
+        }
+    }
+    let totalManagers = constants_1.MAX_MANAGERS_PER_BASKET;
+    while (totalManagers > 0 && basket.settings.managers.managers[totalManagers - 1].equals(web3_js_1.PublicKey.default)) {
+        totalManagers--;
+    }
+    basket.settings.managers.managers = basket.settings.managers.managers.slice(0, totalManagers);
+    basket.settings.managers.managersWeightBps = basket.settings.managers.managersWeightBps.slice(0, totalManagers);
+    basket = Object.assign(Object.assign({}, basket), { metadata: metadata });
+    let creator_settings = {
+        creator: basket.settings.creator.toBase58(),
+    };
+    let manager_settings = {
+        managers: basket.settings.managers.managers.map((manager, i) => ({
+            pubkey: manager.toBase58(),
+            fee_split_weight_bps: basket.settings.managers.managersWeightBps[i],
+            authorities: {
+                managers: (((2 ** i) & basket.settings.managersAuthorityBitmask) != 0),
+                fees: (((2 ** i) & basket.settings.feesAuthorityBitmask) != 0),
+                schedule: (((2 ** i) & basket.settings.scheduleAuthorityBitmask) != 0),
+                automation: (((2 ** i) & basket.settings.automationAuthorityBitmask) != 0),
+                lp: (((2 ** i) & basket.settings.lpAuthorityBitmask) != 0),
+                metadata: (((2 ** i) & basket.settings.metadataAuthorityBitmask) != 0),
+                deposits: (((2 ** i) & basket.settings.depositsAuthorityBitmask) != 0),
+                force_rebalance: (((2 ** i) & basket.settings.forceRebalanceAuthorityBitmask) != 0),
+                custom_rebalance: (((2 ** i) & basket.settings.customRebalanceAuthorityBitmask) != 0),
+                add_token: (((2 ** i) & basket.settings.addTokenIntentAuthorityBitmask) != 0),
+                update_weights: (((2 ** i) & basket.settings.updateWeightsIntentAuthorityBitmask) != 0),
+                make_direct_swap: (((2 ** i) & basket.settings.makeDirectSwapIntentAuthorityBitmask) != 0),
+            },
+        })),
+        modification_delay: parseInt(basket.settings.managers.modificationDelay.toString()),
+        updated_at: parseInt(basket.settings.managersLastUpdateTimestamp.toString()),
+    };
+    let fee_settings = {
+        host_deposit_fee_bps: basket.settings.fees.hostDepositFeeBps,
+        host_withdraw_fee_bps: basket.settings.fees.hostWithdrawFeeBps,
+        host_management_fee_bps: basket.settings.fees.hostManagementFeeBps,
+        host_performance_fee_bps: basket.settings.fees.hostPerformanceFeeBps,
+        creator_deposit_fee_bps: basket.settings.fees.creatorDepositFeeBps,
+        creator_withdraw_fee_bps: basket.settings.fees.creatorWithdrawFeeBps,
+        creator_management_fee_bps: basket.settings.fees.creatorManagementFeeBps,
+        creator_performance_fee_bps: basket.settings.fees.creatorPerformanceFeeBps,
+        managers_deposit_fee_bps: basket.settings.fees.managersDepositFeeBps,
+        managers_withdraw_fee_bps: basket.settings.fees.managersWithdrawFeeBps,
+        managers_management_fee_bps: basket.settings.fees.managersManagementFeeBps,
+        managers_performance_fee_bps: basket.settings.fees.managersPerformanceFeeBps,
+        basket_deposit_fee_bps: basket.settings.fees.basketDepositFeeBps,
+        basket_withdraw_fee_bps: basket.settings.fees.basketWithdrawFeeBps,
+        modification_delay: parseInt(basket.settings.fees.modificationDelay.toString()),
+        updated_at: parseInt(basket.settings.feesLastUpdateTimestamp.toString()),
+    };
+    let schedule_settings = {
+        cycle_start_time: parseInt(basket.settings.schedule.cycleStartTime.toString()),
+        cycle_duration: parseInt(basket.settings.schedule.cycleDuration.toString()),
+        deposits_start: parseInt(basket.settings.schedule.depositsStart.toString()),
+        deposits_end: parseInt(basket.settings.schedule.depositsEnd.toString()),
+        automation_start: parseInt(basket.settings.schedule.automationStart.toString()),
+        automation_end: parseInt(basket.settings.schedule.automationEnd.toString()),
+        management_start: parseInt(basket.settings.schedule.managementStart.toString()),
+        management_end: parseInt(basket.settings.schedule.managementEnd.toString()),
+        modification_delay: parseInt(basket.settings.schedule.modificationDelay.toString()),
+        updated_at: parseInt(basket.settings.scheduleLastUpdateTimestamp.toString()),
+    };
+    let automation_settings = {
+        enabled: basket.settings.automation.allowAutomation == 1 ? true : false,
+        rebalance_slippage_threshold_bps: basket.settings.automation.rebalanceSlippageThresholdBps,
+        per_trade_rebalance_slippage_threshold_bps: basket.settings.automation.perTradeRebalanceSlippageThresholdBps,
+        rebalance_activation_threshold_abs_bps: basket.settings.automation.rebalanceActivationThresholdAbsBps,
+        rebalance_activation_threshold_rel_bps: basket.settings.automation.rebalanceActivationThresholdRelBps,
+        rebalance_activation_cooldown: parseInt(basket.settings.automation.rebalanceActivationCooldown.toString()),
+        modification_delay: parseInt(basket.settings.automation.modificationDelay.toString()),
+        updated_at: parseInt(basket.settings.automationLastUpdateTimestamp.toString()),
+    };
+    let lp_settings = {
+        enabled: basket.settings.lp.allowLp == 1 ? true : false,
+        lp_threshold_bps: basket.settings.lp.lpThresholdBps,
+        modification_delay: parseInt(basket.settings.lp.modificationDelay.toString()),
+        updated_at: parseInt(basket.settings.lpLastUpdateTimestamp.toString()),
+    };
+    let metadata_settings = {
+        symbol: metadata.symbol,
+        name: metadata.name,
+        uri: metadata.uri,
+        modification_delay: parseInt(basket.settings.metadata.modificationDelay.toString()),
+        updated_at: parseInt(basket.settings.metadataLastUpdateTimestamp.toString()),
+    };
+    let deposits_settings = {
+        enabled: basket.settings.depositsAreAllowed == 1 ? true : false,
+    };
+    let force_rebalance_settings = {
+        enabled: basket.settings.forceRebalanceIsAllowed == 1 ? true : false,
+        modification_delay: parseInt(basket.settings.forceRebalanceModificationDelay.toString()),
+        updated_at: parseInt(basket.settings.forceRebalanceLastUpdateTimestamp.toString()),
+    };
+    let custom_rebalance_settings = {
+        enabled: basket.settings.customRebalanceIsAllowed == 1 ? true : false,
+        modification_delay: parseInt(basket.settings.customRebalanceModificationDelay.toString()),
+        updated_at: parseInt(basket.settings.customRebalanceLastUpdateTimestamp.toString()),
+    };
+    let add_token_settings = {
+        modification_delay: parseInt(basket.settings.addTokenDelay.toString()),
+        updated_at: parseInt(basket.settings.addTokenLastUpdateTimestamp.toString()),
+    };
+    let update_weights_settings = {
+        modification_delay: parseInt(basket.settings.updateWeightsDelay.toString()),
+        updated_at: parseInt(basket.settings.updateWeightsLastUpdateTimestamp.toString()),
+    };
+    let make_direct_swap_settings = {
+        modification_delay: parseInt(basket.settings.makeDirectSwapDelay.toString()),
+        updated_at: parseInt(basket.settings.makeDirectSwapLastUpdateTimestamp.toString()),
+    };
+    let accumulated_fees = {
+        symmetry_fees: parseInt(basket.accumulatedFees.symmetryFees.toString()),
+        creator_fees: parseInt(basket.accumulatedFees.creatorFees.toString()),
+        host_fees: parseInt(basket.accumulatedFees.hostFees.toString()),
+        managers_fees: parseInt(basket.accumulatedFees.managersFees.toString()),
+    };
+    let lookup_tables = {
+        active: [
+            {
+                pubkey: basket.lookupTables.active[0].toBase58(),
+                contents: ((_b = (_a = basket.lutPubkeys) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.state.addresses.map(address => address.toBase58())) || [],
+            },
+            {
+                pubkey: basket.lookupTables.active[1].toBase58(),
+                contents: ((_d = (_c = basket.lutPubkeys) === null || _c === void 0 ? void 0 : _c[1]) === null || _d === void 0 ? void 0 : _d.state.addresses.map(address => address.toBase58())) || [],
+            },
+        ],
+        temp: [
+            {
+                pubkey: basket.lookupTables.temp[0].toBase58(),
+                contents: ((_f = (_e = basket.lutPubkeys) === null || _e === void 0 ? void 0 : _e[2]) === null || _f === void 0 ? void 0 : _f.state.addresses.map(address => address.toBase58())) || [],
+            },
+            {
+                pubkey: basket.lookupTables.temp[1].toBase58(),
+                contents: ((_h = (_g = basket.lutPubkeys) === null || _g === void 0 ? void 0 : _g[3]) === null || _h === void 0 ? void 0 : _h.state.addresses.map(address => address.toBase58())) || [],
+            },
+        ],
+    };
+    let composition = basket.composition.map(asset => ({
+        mint: asset.mint.toBase58(),
+        amount: parseInt(asset.amount.toString()),
+        weight: asset.weight,
+        active: asset.active == 1 ? true : false,
+        oracle_aggregator: {
+            num_oracles: asset.oracleAggregator.numOracles,
+            min_oracles_thresh: asset.oracleAggregator.minOraclesThresh,
+            oracles: asset.oracleAggregator.oracles.map(oracle => {
+                var _a;
+                return ({
+                    oracle_settings: {
+                        oracle_type: (_a = oracle_1.ORACLE_TYPES_STRINGS.get(oracle.oracleSettings.oracleType)) !== null && _a !== void 0 ? _a : "example",
+                        account_lut_id: oracle.accountsToLoadLutIds[0],
+                        account_lut_index: oracle.accountsToLoadLutIndices[0],
+                        account: lookup_tables.active[oracle.accountsToLoadLutIds[0]].contents[oracle.accountsToLoadLutIndices[0]],
+                        num_required_accounts: oracle.oracleSettings.numRequiredAccounts,
+                        weight: oracle.oracleSettings.weight,
+                        is_required: oracle.oracleSettings.isRequired == 1 ? true : false,
+                        conf_thresh_bps: oracle.oracleSettings.confThreshBps,
+                        volatility_thresh_bps: oracle.oracleSettings.volatilityThreshBps,
+                        max_slippage_bps: oracle.oracleSettings.maxSlippageBps,
+                        min_liquidity: parseInt(oracle.oracleSettings.minLiquidity.toString()),
+                        staleness_thresh: parseInt(oracle.oracleSettings.stalenessThresh.toString()),
+                        staleness_conf_rate_bps: oracle.oracleSettings.stalenessConfRateBps,
+                        token_decimals: oracle.oracleSettings.tokenDecimals,
+                        twap_seconds_ago: parseInt(oracle.oracleSettings.twapSecondsAgo.toString()),
+                        twap_secondary_seconds_ago: parseInt(oracle.oracleSettings.twapSecondarySecondsAgo.toString()),
+                        quote: oracle.oracleSettings.quote == 0 ? "usdc" : "wsol",
+                        side: oracle.oracleSettings.side == 0 ? "base" : "quote",
+                    },
+                    accounts_to_load_lut_ids: oracle.accountsToLoadLutIds.map(id => id),
+                    accounts_to_load_lut_indices: oracle.accountsToLoadLutIndices.map(index => index),
+                });
+            }),
+            min_conf_bps: asset.oracleAggregator.minConfBps,
+            conf_thresh_bps: asset.oracleAggregator.confThreshBps,
+            conf_multiplier: (0, fraction_1.fractionToDecimal)(asset.oracleAggregator.confMultiplier).toNumber(),
+        },
+    }));
+    let formatted = {
+        pubkey: basket.ownAddress.toBase58(),
+        name: ((_j = basket.metadata) === null || _j === void 0 ? void 0 : _j.name) || "",
+        symbol: ((_k = basket.metadata) === null || _k === void 0 ? void 0 : _k.symbol) || "",
+        uri: ((_l = basket.metadata) === null || _l === void 0 ? void 0 : _l.uri) || "",
+        version: basket.version,
+        own_address: basket.ownAddress.toBase58(),
+        mint: basket.mint.toBase58(),
+        supply_outstanding: parseInt(basket.supplyOutstanding.toString()),
+        creator: basket.settings.creator.toBase58(),
+        host: basket.settings.host.toBase58(),
+        basket_type: (_m = basket_1.BASKET_TYPES_STRINGS.get(basket.settings.basketType)) !== null && _m !== void 0 ? _m : "private",
+        bounty_mint: basket.settings.bountyMint.toBase58(),
+        bounty_balance: parseInt(basket.settings.bountyBalance.toString()),
+        start_price: (0, fraction_1.fractionToDecimal)(basket.settings.startPrice).toNumber(),
+        high_watermark: (0, fraction_1.fractionToDecimal)(basket.settings.highWaterMark).toNumber(),
+        active_rebalance: parseInt(basket.settings.activeRebalance.toString()),
+        active_withdraws: parseInt(basket.settings.activeWithdraws.toString()),
+        active_managements: parseInt(basket.settings.activeManagements.toString()),
+        last_automation_execution_timestamp: parseInt(basket.settings.lastAutomationExecutionTimestamp.toString()),
+        creator_settings: creator_settings,
+        manager_settings: manager_settings,
+        fee_settings: fee_settings,
+        schedule_settings: schedule_settings,
+        automation_settings: automation_settings,
+        lp_settings: lp_settings,
+        metadata_settings: metadata_settings,
+        deposits_settings: deposits_settings,
+        force_rebalance_settings: force_rebalance_settings,
+        custom_rebalance_settings: custom_rebalance_settings,
+        add_token_settings: add_token_settings,
+        update_weights_settings: update_weights_settings,
+        make_direct_swap_settings: make_direct_swap_settings,
+        accumulated_fees: accumulated_fees,
+        lookup_tables: lookup_tables,
+        composition: composition,
+    };
+    basket = Object.assign(Object.assign({}, basket), { formatted: formatted });
+    return basket;
+}
+function addLutsToBaskets(connection, baskets) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let allLutPubkeys = [];
+        for (let basket of baskets)
+            allLutPubkeys.push([...basket.lookupTables.active, ...basket.lookupTables.temp]);
+        let allInfos = (yield (0, txUtils_1.getMultipleAddressLookupTableAccounts)(connection, [allLutPubkeys]))[0];
+        for (let i = 0; i < baskets.length; i++) {
+            baskets[i].lutPubkeys = allInfos[i];
+        }
+        return baskets;
+    });
+}
+function fetchBasket(connection, basketAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const basketAi = yield connection.getAccountInfo(basketAddress);
+        if (!basketAi)
+            throw new Error("Basket not found");
+        let basket = basket_1.BasketLayout.decode(basketAi.data.slice(8));
+        basket = (yield addLutsToBaskets(connection, [basket]))[0];
+        basket = addFieldsToBasket(basket);
+        return basket;
+    });
+}
+function fetchBasketsMultiple(connection, basketAddresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let multipleAccountsInfo = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, basketAddresses);
+        let baskets = basketAddresses.map(address => {
+            let ai = multipleAccountsInfo.get(address.toBase58());
+            if (!ai)
+                return null;
+            return basket_1.BasketLayout.decode(ai.data.slice(8));
+        }).filter(basket => basket !== null);
+        baskets = yield addLutsToBaskets(connection, baskets);
+        baskets = baskets.map(basket => addFieldsToBasket(basket));
+        let basketsMap = new Map();
+        for (let basket of baskets) {
+            basketsMap.set(basket.ownAddress.toBase58(), basket);
+        }
+        return basketsMap;
+    });
+}
+function fetchBaskets(connection, filter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Managers array begins at this offset in Basket account data.
+        const MANAGERS_ARRAY_OFFSET = 8 + 1 + 32 + 32 + 8 + 32 + 32 + 1 + 32 + 8 + 16 + 16 + 8 + 8 + 8 + 8;
+        const MANAGER_PUBKEY_SIZE = 32;
+        if ((filter === null || filter === void 0 ? void 0 : filter.type) === "manager") {
+            try {
+                const managerPubkey = new web3_js_1.PublicKey(filter.pubkey);
+                const managerBytes = Buffer.from(managerPubkey.toBytes());
+                const managerSliceLength = constants_1.MAX_MANAGERS_PER_BASKET * MANAGER_PUBKEY_SIZE;
+                // Request only manager bytes for each basket (single GPA), then filter locally.
+                const managerSlices = yield connection.getProgramAccounts(constants_1.BASKETS_V3_PROGRAM_ID, {
+                    commitment: "confirmed",
+                    filters: [{ dataSize: 8 + basket_1.BasketLayout.getSpan() }],
+                    dataSlice: {
+                        offset: MANAGERS_ARRAY_OFFSET,
+                        length: managerSliceLength,
+                    },
+                    encoding: 'base64',
+                });
+                const matchedPubkeys = [];
+                for (const basketAccount of managerSlices) {
+                    const managersData = basketAccount.account.data;
+                    for (let i = 0; i < constants_1.MAX_MANAGERS_PER_BASKET; i++) {
+                        const start = i * MANAGER_PUBKEY_SIZE;
+                        const end = start + MANAGER_PUBKEY_SIZE;
+                        if (managersData.subarray(start, end).equals(managerBytes)) {
+                            matchedPubkeys.push(basketAccount.pubkey);
+                            break;
+                        }
+                    }
+                }
+                if (matchedPubkeys.length === 0) {
+                    return [];
+                }
+                const matchedAccountsInfo = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, matchedPubkeys);
+                const accounts = [];
+                for (const pubkey of matchedPubkeys) {
+                    const accountInfo = matchedAccountsInfo.get(pubkey.toBase58());
+                    if (accountInfo) {
+                        accounts.push(accountInfo);
+                    }
+                }
+                let baskets = accounts.map(account => basket_1.BasketLayout.decode(account.data.slice(8)));
+                baskets = yield addLutsToBaskets(connection, baskets);
+                baskets = baskets.map(basket => addFieldsToBasket(basket));
+                return baskets;
+            }
+            catch (error) {
+                // Fallback for RPC providers that might not support/serve this path reliably.
+            }
+        }
+        let filters = [{ dataSize: 8 + basket_1.BasketLayout.getSpan() }];
+        if ((filter === null || filter === void 0 ? void 0 : filter.type) === "creator" || (filter === null || filter === void 0 ? void 0 : filter.type) === "host") {
+            filters.push({
+                memcmp: {
+                    offset: (filter === null || filter === void 0 ? void 0 : filter.type) === "creator" ? 8 + 1 + 32 + 32 + 8 : 8 + 1 + 32 + 32 + 8 + 32,
+                    bytes: filter.pubkey
+                }
+            });
+        }
+        let accounts = yield connection.getProgramAccounts(constants_1.BASKETS_V3_PROGRAM_ID, {
+            commitment: "confirmed",
+            filters: filters,
+            encoding: 'base64'
+        });
+        let baskets = accounts.map(account => basket_1.BasketLayout.decode(account.account.data.slice(8)));
+        baskets = yield addLutsToBaskets(connection, baskets);
+        baskets = baskets.map(basket => addFieldsToBasket(basket));
+        return baskets;
+    });
+}
+function fetchBasketOracleAccountInfos(connection, basket) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let allKeys = [];
+        for (let i = 0; i < basket.numTokens; i++) {
+            let agg = basket.composition[i].oracleAggregator;
+            for (let j = 0; j < agg.numOracles; j++) {
+                const oracleData = agg.oracles[j];
+                for (let k = 0; k < oracleData.oracleSettings.numRequiredAccounts; k++) {
+                    const lutId = oracleData.accountsToLoadLutIds[k];
+                    const lutIdx = oracleData.accountsToLoadLutIndices[k];
+                    if (lutId === 0 && lutIdx === 0)
+                        continue;
+                    if (!basket.lutPubkeys)
+                        continue;
+                    allKeys.push(basket.lutPubkeys[lutId].state.addresses[lutIdx]);
+                }
+            }
+        }
+        allKeys.push(constants_1.PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT);
+        allKeys.push(constants_1.PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT);
+        // load known accounts 
+        const baseInfos = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, allKeys);
+        // derive and bind tick array PDAs for Raydium CLMM, then batch load them
+        const derivedTickArrayKeys = [];
+        for (let i = 0; i < basket.numTokens; i++) {
+            const agg = basket.composition[i].oracleAggregator;
+            for (let j = 0; j < agg.numOracles; j++) {
+                const oracleData = agg.oracles[j];
+                if (oracleData.oracleSettings.oracleType !== oracle_1.OracleType.RaydiumClmm)
+                    continue;
+                const lutId = oracleData.accountsToLoadLutIds[0];
+                const lutIdx = oracleData.accountsToLoadLutIndices[0];
+                if (!basket.lutPubkeys)
+                    continue;
+                const poolPk = basket.lutPubkeys[lutId].state.addresses[lutIdx];
+                const poolAi = baseInfos.get(poolPk.toBase58());
+                if (!poolAi)
+                    continue;
+                const [poolState] = raydiumClmmOracle_1.PoolState.decode(poolAi.data, 8);
+                const currStart = (0, raydiumClmmOracle_1.getTickArrayStartIndexByTick)(poolState.tickCurrent, poolState.tickSpacing);
+                const prevStart = (0, raydiumClmmOracle_1.getNextTickArrayStartIndex)(currStart, poolState.tickSpacing, true);
+                const nextStart = (0, raydiumClmmOracle_1.getNextTickArrayStartIndex)(currStart, poolState.tickSpacing, false);
+                [prevStart, currStart, nextStart].forEach(start => derivedTickArrayKeys.push((0, raydiumClmmOracle_1.getPdaTickArrayAddress)(poolPk, start)));
+            }
+        }
+        let derivedInfos = new Map();
+        derivedInfos = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, derivedTickArrayKeys);
+        derivedInfos.forEach((v, k) => baseInfos.set(k, v));
+        return baseInfos;
+    });
+}
+function loadBasketPrice(basket, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let oracleAccountInfos = yield fetchBasketOracleAccountInfos(connection, basket);
+        let solPrice = pythOracle_1.PythOracle.fetch(oracle_1.PYTH_WSOL_ORACLE_SETTINGS, //@ts-ignore
+        [oracleAccountInfos.get(constants_1.PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT.toBase58())]);
+        let usdcPrice = pythOracle_1.PythOracle.fetch(oracle_1.PYTH_USDC_ORACLE_SETTINGS, //@ts-ignore
+        [oracleAccountInfos.get(constants_1.PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT.toBase58())]);
+        let totalValue = new decimal_js_1.default(0);
+        for (let i = 0; i < basket.numTokens; i++) {
+            const oraclePrice = oracle_2.PriceAggregator.fetch(basket.composition[i].oracleAggregator, //@ts-ignore
+            [basket.lutPubkeys[0], basket.lutPubkeys[1]], oracleAccountInfos, solPrice, usdcPrice);
+            let amount = new decimal_js_1.default(basket.composition[i].amount.toString());
+            const value = oraclePrice.price.mul(amount);
+            basket.composition[i].price = oraclePrice;
+            basket.composition[i].value = value;
+            totalValue = totalValue.add(value);
+        }
+        basket.tvl = totalValue;
+        let supplyOutstanding = new decimal_js_1.default(basket.supplyOutstanding.toString());
+        if (supplyOutstanding.gt(new decimal_js_1.default(0)))
+            basket.price = totalValue.div(supplyOutstanding);
+        return basket;
+    });
+}

package/dist/src/states/config.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from "@solana/web3.js";
+import { GlobalConfig } from "../layouts/config";
+export declare function fetchGlobalConfig(connection: Connection): Promise<GlobalConfig>;

package/dist/src/states/config.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchGlobalConfig = fetchGlobalConfig;
+const config_1 = require("../layouts/config");
+const pda_1 = require("../instructions/pda");
+const fraction_1 = require("../layouts/fraction");
+function fetchGlobalConfig(connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let globalConfig = (0, pda_1.getGlobalConfigPda)();
+        let globalConfigData = yield connection.getAccountInfo(globalConfig);
+        let globalConfigState = config_1.GlobalConfigLayout.decode((_a = globalConfigData === null || globalConfigData === void 0 ? void 0 : globalConfigData.data.slice(8)) !== null && _a !== void 0 ? _a : Buffer.alloc(0));
+        let formatted = {
+            pubkey: globalConfig.toBase58(),
+            admin: globalConfigState.admin.toBase58(),
+            owners: globalConfigState.owners.map(owner => owner.toBase58()),
+            total_number_of_baskets: parseInt(globalConfigState.totalNumberOfBaskets.toString()),
+            allow_interactions: globalConfigState.allowInteractions === 1,
+            allow_creation: globalConfigState.allowCreation === 1,
+            allow_management: globalConfigState.allowManagement === 1,
+            allow_automation: globalConfigState.allowAutomation === 1,
+            allow_deposits: globalConfigState.allowDeposits === 1,
+            allow_withdraws: globalConfigState.allowWithdraws === 1,
+            max_deposit_fee_bps: globalConfigState.maxDepositFeeBps,
+            max_withdraw_fee_bps: globalConfigState.maxWithdrawFeeBps,
+            max_management_fee_bps: globalConfigState.maxManagementFeeBps,
+            max_performance_fee_bps: globalConfigState.maxPerformanceFeeBps,
+            symmetry_fee_collector: globalConfigState.symmetryFeeCollector.toBase58(),
+            symmetry_deposit_fee_bps: globalConfigState.symmetryDepositFeeBps,
+            symmetry_deposit_fee_share_bps: globalConfigState.symmetryDepositFeeShareBps,
+            symmetry_withdraw_fee_bps: globalConfigState.symmetryWithdrawFeeBps,
+            symmetry_withdraw_fee_share_bps: globalConfigState.symmetryWithdrawFeeShareBps,
+            symmetry_management_fee_bps: globalConfigState.symmetryManagementFeeBps,
+            symmetry_management_fee_share_bps: globalConfigState.symmetryManagementFeeShareBps,
+            symmetry_performance_fee_bps: globalConfigState.symmetryPerformanceFeeBps,
+            symmetry_performance_fee_share_bps: globalConfigState.symmetryPerformanceFeeShareBps,
+            symmetry_trade_fee_bps: globalConfigState.symmetryTradeFeeBps,
+            symmetry_limit_order_fee_bps: globalConfigState.symmetryLimitOrderFeeBps,
+            bounty_mint: globalConfigState.bountyMint.toBase58(),
+            min_bounty_for_basket_automation: parseInt(globalConfigState.minBountyForBasketAutomation.toString()),
+            bounty_bond_amount: parseInt(globalConfigState.bountyBondAmount.toString()),
+            bounty_per_task: {
+                min_bounty: parseInt(globalConfigState.bountyPerTask.minBounty.toString()),
+                max_bounty: parseInt(globalConfigState.bountyPerTask.maxBounty.toString()),
+                min_bounty_until: parseInt(globalConfigState.bountyPerTask.minBountyUntil.toString()),
+                max_bounty_after: parseInt(globalConfigState.bountyPerTask.maxBountyAfter.toString()),
+            },
+            bounty_per_price_update_task_divisor: parseInt(globalConfigState.bountyPerPriceUpdateTaskDivisor.toString()),
+            min_remaining_value: (0, fraction_1.fractionToDecimal)(globalConfigState.minRemainingValue).toNumber(),
+            min_mint_ratio: (0, fraction_1.fractionToDecimal)(globalConfigState.minMintRatio).toNumber(),
+            apr_bps_per_year: globalConfigState.aprBpsPerYear,
+            rebalance_intent_lifetime: parseInt(globalConfigState.rebalanceIntentLifetime.toString()),
+            rebalance_auction_1_timeframe: parseInt(globalConfigState.rebalanceAuction1Timeframe.toString()),
+            rebalance_auction_2_timeframe: parseInt(globalConfigState.rebalanceAuction2Timeframe.toString()),
+            rebalance_auction_3_timeframe: parseInt(globalConfigState.rebalanceAuction3Timeframe.toString()),
+            price_update_delay_after_creation: parseInt(globalConfigState.priceUpdateDelayAfterCreation.toString()),
+            price_update_lifetime: parseInt(globalConfigState.priceUpdateLifetime.toString()),
+            price_update_reexecution_delay: parseInt(globalConfigState.priceUpdateReexecutionDelay.toString()),
+        };
+        return Object.assign(Object.assign({}, globalConfigState), { formatted: formatted });
+    });
+}

package/dist/src/states/intents/intent.d.ts

@@ -0,0 +1,10 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { Intent } from '../../layouts/intents/intent';
+export declare function addFieldsToIntent(intent: Intent): Intent;
+export declare function fetchIntent(connection: Connection, intentAddress: PublicKey): Promise<Intent>;
+export declare function fetchIntentsMultiple(connection: Connection, intentAddresses: PublicKey[]): Promise<Map<string, Intent>>;
+export interface IntentFilter {
+    type: "basket" | "manager";
+    pubkey: string;
+}
+export declare function fetchIntents(connection: Connection, filter?: IntentFilter): Promise<Intent[]>;