@symmetry-hq/sdk 1.0.1

package/dist/src/states/intents/intent.js

@@ -0,0 +1,316 @@
+"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.addFieldsToIntent = addFieldsToIntent;
+exports.fetchIntent = fetchIntent;
+exports.fetchIntentsMultiple = fetchIntentsMultiple;
+exports.fetchIntents = fetchIntents;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../../constants");
+const intent_1 = require("../../layouts/intents/intent");
+const txUtils_1 = require("../../txUtils");
+const config_1 = require("../../layouts/config");
+const bn_js_1 = __importDefault(require("bn.js"));
+const oracle_1 = require("../../layouts/oracle");
+const fraction_1 = require("../../layouts/fraction");
+function decodeTaskDataForType(intent) {
+    let taskType = (0, intent_1.taskTypeFromU8)(intent.taskType);
+    let taskData = intent.taskData;
+    switch (taskType) {
+        case intent_1.TaskType.EditCreator:
+            let editCreator = config_1.EditCreatorLayout.decode(Buffer.from(taskData.slice(0, config_1.EditCreatorLayout.getSpan())));
+            let creator_settings = {
+                creator: editCreator.creator.toBase58(),
+            };
+            return creator_settings;
+        case intent_1.TaskType.EditManagerSettings:
+            let managerSettings = config_1.ManagerSettingsLayout.decode(Buffer.from(taskData.slice(0, config_1.ManagerSettingsLayout.getSpan())));
+            let authorityBitmasks = config_1.AuthorityBitmasksLayout.decode(Buffer.from(taskData.slice(config_1.ManagerSettingsLayout.getSpan(), config_1.ManagerSettingsLayout.getSpan() + config_1.AuthorityBitmasksLayout.getSpan())));
+            let totalManagers = constants_1.MAX_MANAGERS_PER_BASKET;
+            while (totalManagers > 0 && managerSettings.managers[totalManagers - 1].equals(web3_js_1.PublicKey.default)) {
+                totalManagers--;
+            }
+            managerSettings.managers = managerSettings.managers.slice(0, totalManagers);
+            managerSettings.managersWeightBps = managerSettings.managersWeightBps.slice(0, totalManagers);
+            let manager_settings = {
+                managers: managerSettings.managers.map((manager, i) => ({
+                    pubkey: manager.toBase58(),
+                    fee_split_weight_bps: managerSettings.managersWeightBps[i],
+                    authorities: {
+                        managers: (((2 ** i) & authorityBitmasks.managersAuthorityBitmask) != 0),
+                        fees: (((2 ** i) & authorityBitmasks.feesAuthorityBitmask) != 0),
+                        schedule: (((2 ** i) & authorityBitmasks.scheduleAuthorityBitmask) != 0),
+                        automation: (((2 ** i) & authorityBitmasks.automationAuthorityBitmask) != 0),
+                        lp: (((2 ** i) & authorityBitmasks.lpAuthorityBitmask) != 0),
+                        metadata: (((2 ** i) & authorityBitmasks.metadataAuthorityBitmask) != 0),
+                        deposits: (((2 ** i) & authorityBitmasks.depositsAuthorityBitmask) != 0),
+                        force_rebalance: (((2 ** i) & authorityBitmasks.forceRebalanceAuthorityBitmask) != 0),
+                        custom_rebalance: (((2 ** i) & authorityBitmasks.customRebalanceAuthorityBitmask) != 0),
+                        add_token: (((2 ** i) & authorityBitmasks.addTokenIntentAuthorityBitmask) != 0),
+                        update_weights: (((2 ** i) & authorityBitmasks.updateWeightsIntentAuthorityBitmask) != 0),
+                        make_direct_swap: (((2 ** i) & authorityBitmasks.makeDirectSwapIntentAuthorityBitmask) != 0),
+                    },
+                })),
+                modification_delay: parseInt(managerSettings.modificationDelay.toString()),
+            };
+            return manager_settings;
+        case intent_1.TaskType.EditFeeSettings:
+            let editFeeSettings = config_1.FeeSettingsLayout.decode(Buffer.from(taskData.slice(0, config_1.FeeSettingsLayout.getSpan())));
+            let fee_settings = {
+                creator_deposit_fee_bps: editFeeSettings.creatorDepositFeeBps,
+                creator_withdraw_fee_bps: editFeeSettings.creatorWithdrawFeeBps,
+                creator_management_fee_bps: editFeeSettings.creatorManagementFeeBps,
+                creator_performance_fee_bps: editFeeSettings.creatorPerformanceFeeBps,
+                managers_deposit_fee_bps: editFeeSettings.managersDepositFeeBps,
+                managers_withdraw_fee_bps: editFeeSettings.managersWithdrawFeeBps,
+                managers_management_fee_bps: editFeeSettings.managersManagementFeeBps,
+                managers_performance_fee_bps: editFeeSettings.managersPerformanceFeeBps,
+                basket_deposit_fee_bps: editFeeSettings.basketDepositFeeBps,
+                basket_withdraw_fee_bps: editFeeSettings.basketWithdrawFeeBps,
+                modification_delay: parseInt(editFeeSettings.modificationDelay.toString()),
+            };
+            return fee_settings;
+        case intent_1.TaskType.EditScheduleSettings:
+            let editScheduleSettings = config_1.ScheduleSettingsLayout.decode(Buffer.from(taskData.slice(0, config_1.ScheduleSettingsLayout.getSpan())));
+            let schedule_settings = {
+                cycle_start_time: parseInt(editScheduleSettings.cycleStartTime.toString()),
+                cycle_duration: parseInt(editScheduleSettings.cycleDuration.toString()),
+                deposits_start: parseInt(editScheduleSettings.depositsStart.toString()),
+                deposits_end: parseInt(editScheduleSettings.depositsEnd.toString()),
+                automation_start: parseInt(editScheduleSettings.automationStart.toString()),
+                automation_end: parseInt(editScheduleSettings.automationEnd.toString()),
+                management_start: parseInt(editScheduleSettings.managementStart.toString()),
+                management_end: parseInt(editScheduleSettings.managementEnd.toString()),
+                modification_delay: parseInt(editScheduleSettings.modificationDelay.toString()),
+            };
+            return schedule_settings;
+        case intent_1.TaskType.EditAutomationSettings:
+            let editAutomationSettings = config_1.AutomationSettingsLayout.decode(Buffer.from(taskData.slice(0, config_1.AutomationSettingsLayout.getSpan())));
+            let automation_settings = {
+                enabled: editAutomationSettings.allowAutomation == 1 ? true : false,
+                rebalance_slippage_threshold_bps: editAutomationSettings.rebalanceSlippageThresholdBps,
+                per_trade_rebalance_slippage_threshold_bps: editAutomationSettings.perTradeRebalanceSlippageThresholdBps,
+                rebalance_activation_threshold_abs_bps: editAutomationSettings.rebalanceActivationThresholdAbsBps,
+                rebalance_activation_threshold_rel_bps: editAutomationSettings.rebalanceActivationThresholdRelBps,
+                rebalance_activation_cooldown: parseInt(editAutomationSettings.rebalanceActivationCooldown.toString()),
+                modification_delay: parseInt(editAutomationSettings.modificationDelay.toString()),
+            };
+            return automation_settings;
+        case intent_1.TaskType.EditLpSettings:
+            let editLpSettings = config_1.LpSettingsLayout.decode(Buffer.from(taskData.slice(0, config_1.LpSettingsLayout.getSpan())));
+            let lp_settings = {
+                enabled: editLpSettings.allowLp == 1 ? true : false,
+                lp_threshold_bps: editLpSettings.lpThresholdBps,
+                modification_delay: parseInt(editLpSettings.modificationDelay.toString()),
+            };
+            return lp_settings;
+        case intent_1.TaskType.EditMetadataSettings:
+            let editMetadataSettings = config_1.MetadataSettingsLayout.decode(Buffer.from(taskData.slice(0, config_1.MetadataSettingsLayout.getSpan())));
+            let metadata = {
+                symbol: Buffer.from(editMetadataSettings.symbol.slice(0, editMetadataSettings.symbolLength)).toString(),
+                name: Buffer.from(editMetadataSettings.name.slice(0, editMetadataSettings.nameLength)).toString(),
+                uri: Buffer.from(editMetadataSettings.uri.slice(0, editMetadataSettings.uriLength)).toString()
+            };
+            let metadata_settings = {
+                symbol: metadata.symbol,
+                name: metadata.name,
+                uri: metadata.uri,
+                modification_delay: parseInt(editMetadataSettings.modificationDelay.toString()),
+            };
+            return metadata_settings;
+        case intent_1.TaskType.EditDepositsSettings:
+            let deposits_settings = {
+                enabled: taskData[0] == 1 ? true : false,
+            };
+            return deposits_settings;
+        case intent_1.TaskType.EditForceRebalanceSettings:
+            let force_rebalance_settings = {
+                enabled: taskData[0] == 1 ? true : false,
+                modification_delay: parseInt(new bn_js_1.default(Buffer.from(taskData.slice(1, 9)), "le").toString()),
+            };
+            return force_rebalance_settings;
+        case intent_1.TaskType.EditCustomRebalanceSettings:
+            let custom_rebalance_settings = {
+                enabled: taskData[0] == 1 ? true : false,
+                modification_delay: parseInt(new bn_js_1.default(Buffer.from(taskData.slice(1, 9)), "le").toString()),
+            };
+            return custom_rebalance_settings;
+        case intent_1.TaskType.EditAddTokenDelay:
+            let editAddTokenDelay = config_1.EditAddTokenDelayLayout.decode(Buffer.from(taskData.slice(0, config_1.EditAddTokenDelayLayout.getSpan())));
+            let add_token_settings = {
+                modification_delay: parseInt(editAddTokenDelay.modificationDelay.toString()),
+            };
+            return add_token_settings;
+        case intent_1.TaskType.EditUpdateWeightsDelay:
+            let editUpdateWeightsDelay = config_1.EditUpdateWeightsDelayLayout.decode(Buffer.from(taskData.slice(0, config_1.EditUpdateWeightsDelayLayout.getSpan())));
+            let update_weights_settings = {
+                modification_delay: parseInt(editUpdateWeightsDelay.modificationDelay.toString()),
+            };
+            return update_weights_settings;
+        case intent_1.TaskType.EditMakeDirectSwapDelay:
+            let editMakeDirectSwapDelay = config_1.EditMakeDirectSwapDelayLayout.decode(Buffer.from(taskData.slice(0, config_1.EditMakeDirectSwapDelayLayout.getSpan())));
+            let make_direct_swap_settings = {
+                modification_delay: parseInt(editMakeDirectSwapDelay.modificationDelay.toString()),
+            };
+            return make_direct_swap_settings;
+        case intent_1.TaskType.AddToken:
+            let oracleAggregator = oracle_1.OracleAggregatorLayout.decode(Buffer.from(taskData.slice(0, oracle_1.OracleAggregatorLayout.getSpan())));
+            let active = taskData[oracle_1.OracleAggregatorLayout.getSpan()] == 1 ? true : false;
+            let token_mint = new web3_js_1.PublicKey(taskData.slice(oracle_1.OracleAggregatorLayout.getSpan() + 1, oracle_1.OracleAggregatorLayout.getSpan() + 33));
+            let add_token_input = {
+                token_mint: token_mint.toBase58(),
+                active: active,
+                min_oracles_thresh: oracleAggregator.minOraclesThresh,
+                min_conf_bps: oracleAggregator.minConfBps,
+                conf_thresh_bps: oracleAggregator.confThreshBps,
+                conf_multiplier: (0, fraction_1.fractionToDecimal)(oracleAggregator.confMultiplier).toNumber(),
+                oracles: oracleAggregator.oracles.slice(0, oracleAggregator.numOracles).map(oracle => {
+                    var _a;
+                    return ({
+                        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: "",
+                        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()),
+                    });
+                }),
+            };
+            return add_token_input;
+        case intent_1.TaskType.UpdateWeights:
+            let updateWeights = config_1.UpdateWeightsLayout.decode(Buffer.from(taskData.slice(0, config_1.UpdateWeightsLayout.getSpan())));
+            let update_weights_input = {
+                token_weights: updateWeights.tokenWeights.map(weight => ({
+                    mint: "",
+                    weight_bps: weight,
+                })),
+                token_mints_hash: updateWeights.tokenMintsHash,
+            };
+            return update_weights_input;
+        case intent_1.TaskType.MakeDirectSwap:
+            let makeDirectSwap = config_1.MakeDirectSwapLayout.decode(Buffer.from(taskData.slice(0, config_1.MakeDirectSwapLayout.getSpan())));
+            let make_direct_swap_input = {
+                from_token_mint: makeDirectSwap.fromTokenMint.toBase58(),
+                to_token_mint: makeDirectSwap.toTokenMint.toBase58(),
+                amount_from: parseInt(makeDirectSwap.amountFrom.toString()),
+                amount_to: parseInt(makeDirectSwap.amountTo.toString()),
+            };
+            return make_direct_swap_input;
+        default:
+            throw new Error(`Unknown task type: ${taskType}`);
+    }
+}
+;
+function addFieldsToIntent(intent) {
+    var _a, _b;
+    let formatted = {
+        pubkey: intent.ownAddress.toBase58(),
+        manager: intent.manager.toBase58(),
+        status: (_a = intent_1.INTENT_STATUS_STRINGS.get(intent.status)) !== null && _a !== void 0 ? _a : "not_active",
+        activation_timestamp: parseInt(intent.activationTimestamp.toString()),
+        expiration_timestamp: parseInt(intent.expirationTimestamp.toString()),
+        basket: intent.basket.toBase58(),
+        bounty: {
+            bounty_depositor: intent.bounty.bountyDepositor.toBase58(),
+            bounty_mint: intent.bounty.bountyMint.toBase58(),
+            bounty_per_price_update_task: {
+                min_bounty: parseInt(intent.bounty.bountyPerPriceUpdateTask.minBounty.toString()),
+                max_bounty: parseInt(intent.bounty.bountyPerPriceUpdateTask.maxBounty.toString()),
+                min_bounty_until: parseInt(intent.bounty.bountyPerPriceUpdateTask.minBountyUntil.toString()),
+                max_bounty_after: parseInt(intent.bounty.bountyPerPriceUpdateTask.maxBountyAfter.toString()),
+            },
+            bounty_per_task: {
+                min_bounty: parseInt(intent.bounty.bountyPerTask.minBounty.toString()),
+                max_bounty: parseInt(intent.bounty.bountyPerTask.maxBounty.toString()),
+                min_bounty_until: parseInt(intent.bounty.bountyPerTask.minBountyUntil.toString()),
+                max_bounty_after: parseInt(intent.bounty.bountyPerTask.maxBountyAfter.toString()),
+            },
+            bounty_total: parseInt(intent.bounty.bountyTotal.toString()),
+            bounty_left: parseInt(intent.bounty.bountyLeft.toString()),
+        },
+        task_type: (_b = intent_1.TASK_TYPE_STRINGS.get(intent.taskType)) !== null && _b !== void 0 ? _b : "unknown",
+        task_data: decodeTaskDataForType(intent),
+    };
+    intent.formatted = formatted;
+    return intent;
+}
+function fetchIntent(connection, intentAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const intentAi = yield connection.getAccountInfo(intentAddress);
+        if (!intentAi)
+            throw new Error('Basket intent not found');
+        let intent = intent_1.IntentLayout.decode(intentAi.data.slice(8));
+        intent.ownAddress = intentAddress;
+        intent = addFieldsToIntent(intent);
+        return intent;
+    });
+}
+function fetchIntentsMultiple(connection, intentAddresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let multipleAccountsInfo = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, intentAddresses);
+        let intents = intentAddresses.map(address => {
+            let ai = multipleAccountsInfo.get(address.toBase58());
+            if (!ai)
+                return null;
+            return Object.assign(Object.assign({}, intent_1.IntentLayout.decode(ai.data.slice(8))), { ownAddress: address });
+        }).filter(intent => intent !== null);
+        intents = intents.map(intent => addFieldsToIntent(intent));
+        let intentsMap = new Map();
+        for (let intent of intents)
+            intentsMap.set(intent.ownAddress.toBase58(), intent);
+        return intentsMap;
+    });
+}
+function fetchIntents(connection, filter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let accountFilters = [
+            { dataSize: 8 + intent_1.IntentLayout.getSpan() },
+        ];
+        if ((filter === null || filter === void 0 ? void 0 : filter.type) === "basket") {
+            accountFilters.push({ memcmp: {
+                    offset: 8 + 32 + 1 + 8 + 8,
+                    bytes: filter.pubkey
+                } });
+        }
+        else if ((filter === null || filter === void 0 ? void 0 : filter.type) === "manager") {
+            accountFilters.push({ memcmp: {
+                    offset: 8,
+                    bytes: filter.pubkey
+                } });
+        }
+        const accounts = yield connection
+            .getProgramAccounts(constants_1.BASKETS_V3_PROGRAM_ID, {
+            commitment: "confirmed",
+            filters: accountFilters,
+            encoding: 'base64'
+        });
+        let intents = accounts.map(account => {
+            let intent = intent_1.IntentLayout.decode(account.account.data.slice(8));
+            intent.ownAddress = account.pubkey;
+            return intent;
+        });
+        intents = intents.map(intent => addFieldsToIntent(intent));
+        return intents;
+    });
+}

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

@@ -0,0 +1,42 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { RebalanceIntent, RebalanceType, UIRebalanceIntent } from "../../layouts/intents/rebalanceIntent";
+import { Basket, FormattedBasket } from "../../layouts/basket";
+export declare function computeRebalanceIntentBountyAmount(rebalance_type: RebalanceType, num_tokens: number, bounty_bond: number, bounty_per_task: number, bounty_per_price_update_task_max: number): number;
+export declare function formatRebalanceIntent(rebalanceIntent: RebalanceIntent, basket?: FormattedBasket): UIRebalanceIntent;
+export declare function fetchRebalanceIntent(connection: Connection, rebalanceIntentAddress: PublicKey): Promise<UIRebalanceIntent>;
+export declare function fetchRebalanceIntentsMultiple(connection: Connection, rebalanceIntentAddresses: PublicKey[]): Promise<Map<string, UIRebalanceIntent>>;
+export interface RebalanceIntentFilter {
+    type: "basket" | "owner";
+    pubkey: string;
+}
+export declare function fetchRebalanceIntents(connection: Connection, filter?: RebalanceIntentFilter): Promise<UIRebalanceIntent[]>;
+/**
+ * Returns all valid swap pairs available during the rebalance auction phase.
+ *
+ * **Swap direction (basket perspective):**
+ * - `inMint` / `inAmount`: what the basket is supposed to **receive**.
+ * - `outMint` / `outAmount`: what the basket wants to **swap** (give away).
+ * So each pair describes an **outMint → inMint** swap. When generating swap
+ * transactions, use this direction: swap `outMint` → `inMint` (sell outAmount of
+ * outMint, receive inAmount of inMint).
+ *
+ * Only runs when the rebalance is in Auction action and the current time falls
+ * within one of the three auction windows. For the active auction, target amounts
+ * are refreshed if they haven't been updated since the auction started.
+ *
+ * Iterates over completed price-update tokens to compute exchange rates via
+ * getSwapAmounts (using time-since-start and auction duration). Pairs with
+ * positive in/out amounts are collected and sorted by value descending
+ * (highest value first).
+ *
+ * @param rebalanceIntent - The rebalance intent state
+ * @param basket - The basket (used to update target amounts when needed)
+ * @returns Array of swap pairs, or empty array when not in auction or outside auction windows
+ */
+export declare function getSwapPairs(rebalanceIntent: RebalanceIntent, basket: Basket): {
+    inMint: string;
+    outMint: string;
+    inAmount: number;
+    outAmount: number;
+    value: number;
+}[];