@symmetry-hq/temp-v3-sdk 0.0.7 → 0.0.8

package/dist/src/index.js

@@ -217,7 +217,6 @@ class SymmetryCore {
                     rebalanceIntent: rebalanceIntent,
                 }),
             ]);
-            // batchIxs = [batchIxs[batchIxs.length - 1]];
             let signers = [];
             let multipleLookupTableAddresses = [];
             for (let i = 0; i < batchIxs.length; i++) {

package/dist/src/instructions/automation/priceUpdate.js

@@ -10,7 +10,7 @@ const UPDATE_TOKEN_PRICES_DISCRIMINATOR = Buffer.from([147, 87, 140, 33, 214, 18
 function startPriceUpdatesIx(params) {
     const keys = [
         { pubkey: params.keeper, isSigner: true, isWritable: true },
-        { pubkey: params.basket, isSigner: false, isWritable: false },
+        { pubkey: params.basket, isSigner: false, isWritable: true },
         { pubkey: params.rebalanceIntent, isSigner: false, isWritable: true },
     ];
     const data = START_PRICE_UPDATES_DISCRIMINATOR;

package/dist/src/instructions/management/edit.js

@@ -162,7 +162,12 @@ function createEditBasketIntentIx(params) {
             }
             break;
         case intent_1.TaskType.UpdateWeights: // 10
-            intent_1.UpdateWeightsLayout.encode(editData, editDataBuf);
+            let updateWeightsData = editData;
+            while (updateWeightsData.tokenMintsHash.length < 32)
+                updateWeightsData.tokenMintsHash.push(0);
+            while (updateWeightsData.tokenWeights.length < constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET)
+                updateWeightsData.tokenWeights.push(0);
+            intent_1.UpdateWeightsLayout.encode(updateWeightsData, editDataBuf);
             break;
         case intent_1.TaskType.Swap: // 11
             break;

package/dist/src/layouts/basket.d.ts

@@ -22,6 +22,7 @@ export interface Asset {
     mint: PublicKey;
     amount: BN;
     weight: number;
+    active: number;
     oracleAggregator: OracleAggregator;
     price?: OraclePrice;
     value?: Decimal;
@@ -43,7 +44,6 @@ export interface Basket {
     settings: BasketSettings;
     accumulatedFees: BasketFees;
     lookupTables: LookupTables;
-    writeVersion: BN;
     numTokens: number;
     composition: Asset[];
     lutPubkeys?: AddressLookupTableAccount[];

package/dist/src/layouts/basket.js

@@ -23,6 +23,7 @@ exports.AssetLayout = (0, borsh_1.struct)([
     (0, borsh_1.publicKey)('mint'),
     (0, borsh_1.u64)('amount'),
     (0, borsh_1.u16)('weight'),
+    (0, borsh_1.u8)('active'),
     oracle_1.OracleAggregatorLayout.replicate('oracleAggregator'),
 ]);
 ;
@@ -37,7 +38,6 @@ exports.BasketLayout = (0, borsh_1.struct)([
     config_1.BasketSettingsLayout.replicate('settings'),
     exports.BasketFeesLayout.replicate('accumulatedFees'),
     exports.LookupTablesLayout.replicate('lookupTables'),
-    (0, borsh_1.u64)('writeVersion'),
     (0, borsh_1.u8)('numTokens'),
     (0, borsh_1.array)(exports.AssetLayout, exports.MAX_SUPPORTED_TOKENS_PER_BASKET, 'composition'),
 ]);

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

@@ -24,6 +24,7 @@ export interface Intent {
 export declare const IntentLayout: any;
 export interface HostFees {
     hostDepositFeeBps: number;
+    hostWithdrawalFeeBps: number;
     hostManagementFeeBps: number;
     hostPerformanceFeeBps: number;
 }
@@ -83,7 +84,7 @@ export interface AddToken {
 export declare const AddTokenLayout: any;
 export interface UpdateWeights {
     tokenWeights: number[];
-    writeVersion: BN;
+    tokenMintsHash: number[];
 }
 export declare const UpdateWeightsLayout: any;
 export interface Swap {

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

@@ -27,6 +27,7 @@ exports.IntentLayout = (0, borsh_1.struct)([
 ]);
 exports.HostFeesLayout = (0, borsh_1.struct)([
     (0, borsh_1.u16)('hostDepositFeeBps'),
+    (0, borsh_1.u16)('hostWithdrawalFeeBps'),
     (0, borsh_1.u16)('hostManagementFeeBps'),
     (0, borsh_1.u16)('hostPerformanceFeeBps'),
 ]);

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

@@ -47,7 +47,7 @@ export interface RebalanceIntent {
     perTradeRebalanceThresholdSlippageBps: number;
     initialTvl: Fraction;
     auctionUpdateTimestamp: BN;
-    auctions: AuctionTimestamps;
+    auctions: AuctionTimestamps[];
     tokens: TokenAuction[];
     lastActionTimestamp: BN;
     bounty: Bounty;

package/dist/src/states/basket.js

@@ -22,9 +22,10 @@ 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 oracle_2 = require("./oracles/oracle");
 const txUtils_1 = require("../txUtils");
+const oracle_2 = require("./oracles/oracle");
 const pythOracle_1 = require("./oracles/pythOracle");
+const raydiumClmmOracle_1 = require("./oracles/raydiumClmmOracle");
 function decodeBasket(dataWithoutDiscriminator) {
     let basket = basket_1.BasketLayout.decode(dataWithoutDiscriminator);
     let metadataSettings = basket.settings.metadataSettings;
@@ -102,6 +103,28 @@ function fetchBaskets(connection, filters) {
         return baskets;
     });
 }
+// export async function getBasketOracleAccountInfos(
+//     connection: Connection,
+//     basket: Basket,
+// ): Promise<Map<string, AccountInfo<Buffer> | null>> {
+//     let allKeys: PublicKey[] = [];
+//     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(PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT);
+//     allKeys.push(PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT);
+//     return await getMultipleAccountsInfoBatched(connection, allKeys);
+// }
 function getBasketOracleAccountInfos(connection, basket) {
     return __awaiter(this, void 0, void 0, function* () {
         let allKeys = [];
@@ -122,7 +145,35 @@ function getBasketOracleAccountInfos(connection, basket) {
         }
         allKeys.push(constants_1.PYTHNET_CUSTODY_PRICE_WSOL_ACCOUNT);
         allKeys.push(constants_1.PYTHNET_CUSTODY_PRICE_USDC_ACCOUNT);
-        return yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, allKeys);
+        // 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) {
@@ -136,14 +187,14 @@ function loadBasketPrice(basket, connection) {
         for (let i = 0; i < basket.numTokens; i++) {
             const oraclePrice = oracle_2.PriceAggregator.fetch(basket.composition[i].oracleAggregator, //@ts-ignore
             basket.lutPubkeys, oracleAccountInfos, usdcPrice, solPrice);
-            let amount = new decimal_js_1.default(parseInt(basket.composition[i].amount.toString()));
+            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(parseInt(basket.supplyOutstanding.toString()));
+        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/oracles/oracle.d.ts

@@ -1,7 +1,7 @@
-import { AccountInfo, AddressLookupTableAccount } from "@solana/web3.js";
-import { Fraction } from "../../layouts/fraction";
-import { OracleAggregator, OracleData } from "../../layouts/oracle";
-import Decimal from "decimal.js";
+import Decimal from 'decimal.js';
+import { AccountInfo, AddressLookupTableAccount } from '@solana/web3.js';
+import { Fraction } from '../../layouts/fraction';
+import { OracleAggregator, OracleData } from '../../layouts/oracle';
 export declare class OraclePrice {
     price: Decimal;
     conf: Decimal;

package/dist/src/states/oracles/oracle.js

@@ -4,15 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriceAggregator = exports.OraclePrice = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const anchor_1 = require("@coral-xyz/anchor");
+const constants_1 = require("../../constants");
 const fraction_1 = require("../../layouts/fraction");
 const oracle_1 = require("../../layouts/oracle");
-const constants_1 = require("./constants");
-const anchor_1 = require("@coral-xyz/anchor");
-const decimal_js_1 = __importDefault(require("decimal.js"));
-const raydiumCpmmOracle_1 = require("./raydiumCpmmOracle");
+const constants_2 = require("./constants");
 const pythOracle_1 = require("./pythOracle");
 const raydiumClmmOracle_1 = require("./raydiumClmmOracle");
-const constants_2 = require("../../constants");
+const raydiumCpmmOracle_1 = require("./raydiumCpmmOracle");
 class OraclePrice {
     constructor(price, conf, updateTime) {
         this.price = price;
@@ -51,8 +51,8 @@ class PriceAggregator {
             throw new Error(`Minimum confidence must be between 0 and 10000`);
         if (!(0 <= this.confThreshBps && this.confThreshBps < 10000))
             throw new Error(`Confidence threshold must be between 0 and 10000`);
-        if (!(0 <= this.minOraclesThresh && this.minOraclesThresh <= constants_1.U32_MAX))
-            throw new Error(`Minimum number of oracles must be between 0 and ${constants_1.U32_MAX}`);
+        if (!(0 <= this.minOraclesThresh && this.minOraclesThresh <= constants_2.U32_MAX))
+            throw new Error(`Minimum number of oracles must be between 0 and ${constants_2.U32_MAX}`);
     }
     static fetch(oracleAggregator, lutAccounts, accountInfoMap, solPrice, usdPrice) {
         const agg = oracleAggregator;
@@ -60,17 +60,35 @@ class PriceAggregator {
         for (let i = 0; i < agg.numOracles; i++) {
             const oracleData = agg.oracles[i];
             const settings = oracleData.oracleSettings;
-            const loadedAccounts = [];
-            for (let j = 0; j < oracleData.oracleSettings.numRequiredAccounts; j++) {
+            let loadedAccounts = [];
+            for (let j = 0; j < settings.numRequiredAccounts; j++) {
                 const lutId = oracleData.accountsToLoadLutIds[j];
                 const lutIdx = oracleData.accountsToLoadLutIndices[j];
                 if (lutId === 0 && lutIdx === 0)
                     continue;
-                let pubkey = lutAccounts[lutId].state.addresses[lutIdx];
-                let account = accountInfoMap.get(pubkey.toBase58());
-                //@ts-ignore
+                const pubkey = lutAccounts[lutId].state.addresses[lutIdx];
+                const account = accountInfoMap.get(pubkey.toBase58());
+                // @ts-ignore
                 loadedAccounts.push(account);
             }
+            if (settings.oracleType === oracle_1.OracleType.RaydiumClmm) {
+                // ensure tick arrays are appended in order: prev, current, next
+                const poolPubkey = lutAccounts[oracleData.accountsToLoadLutIds[0]].state.addresses[oracleData.accountsToLoadLutIndices[0]];
+                const poolAi = accountInfoMap.get(poolPubkey.toBase58());
+                if (poolAi) {
+                    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);
+                    const poolId = poolPubkey;
+                    [prevStart, currStart, nextStart].forEach(start => {
+                        const pk = (0, raydiumClmmOracle_1.getPdaTickArrayAddress)(poolId, start);
+                        const ai = accountInfoMap.get(pk.toBase58());
+                        if (ai)
+                            loadedAccounts.push(ai);
+                    });
+                }
+            }
             let result = (() => {
                 switch (settings.oracleType) {
                     case oracle_1.OracleType.Pyth:
@@ -91,6 +109,7 @@ class PriceAggregator {
             }
             oracleResults.push(result);
         }
+        // check this
         if (oracleResults.length < agg.minOraclesThresh)
             return new OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), new anchor_1.BN(0));
         let prices = [];
@@ -107,11 +126,12 @@ class PriceAggregator {
         let first = medianPrice.sub(p25Price);
         let second = p75Price.sub(medianPrice);
         let conf = first.gte(second) ? first : second;
-        conf = conf.lte(medianPrice) ? conf : medianPrice;
+        // confidence should be strictly less than median price
+        conf = conf.lt(medianPrice) ? conf : medianPrice;
         conf = conf.mul((0, fraction_1.fractionToDecimal)(agg.confMultiplier));
-        if (conf.div(medianPrice).mul(new decimal_js_1.default(constants_2.HUNDRED_PERCENT_BPS)).lt(new decimal_js_1.default(agg.minConfBps)))
-            conf = medianPrice.mul(new decimal_js_1.default(agg.minConfBps)).div(new decimal_js_1.default(constants_2.HUNDRED_PERCENT_BPS));
-        if (conf.div(medianPrice).mul(new decimal_js_1.default(constants_2.HUNDRED_PERCENT_BPS)).gt(new decimal_js_1.default(agg.confThreshBps)))
+        if (conf.div(medianPrice).mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS)).lt(new decimal_js_1.default(agg.minConfBps)))
+            conf = medianPrice.mul(new decimal_js_1.default(agg.minConfBps)).div(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS));
+        if (conf.div(medianPrice).mul(new decimal_js_1.default(constants_1.HUNDRED_PERCENT_BPS)).gt(new decimal_js_1.default(agg.confThreshBps)))
             return new OraclePrice(new decimal_js_1.default(0), new decimal_js_1.default(0), 0);
         const oldest = Math.min(...oracleResults.map(p => p.updateTime));
         return new OraclePrice(medianPrice, conf, oldest);

package/dist/src/states/oracles/pythOracle.d.ts

@@ -1,5 +1,6 @@
 import { BN } from '@coral-xyz/anchor';
-import { AccountInfo } from '@solana/web3.js';
+import { HermesClient } from '@pythnetwork/hermes-client';
+import { AccountInfo, Connection, Keypair, PublicKey, Signer, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 import { OracleSettings } from '../../layouts/oracle';
 import { OraclePrice } from './oracle';
 export type VerificationLevel = {
@@ -12,6 +13,146 @@ export declare function parseVerificationLevel(buf: Buffer, offset: number): {
     level: VerificationLevel;
     size: number;
 };
+export declare const TIP_ACCOUNTS: string[];
+export declare function getRandomTipAccount(): PublicKey;
+export declare function buildJitoTipInstruction(payer: PublicKey, lamports: number): TransactionInstruction;
+/**
+ * Derives the Pyth price feed account address
+ */
+export declare function getPythPriceFeedAccountAddress(shardId: number, priceFeedId: string | Buffer, pushOracleProgramId?: PublicKey): PublicKey;
+export interface InstructionWithSigners {
+    instruction: TransactionInstruction;
+    signers: Keypair[];
+    computeUnits?: number;
+}
+export interface PythUpdateResult {
+    postInstructions: InstructionWithSigners[];
+    closeInstructions: InstructionWithSigners[];
+    signers: Keypair[];
+    priceFeedAccounts: Map<string, PublicKey>;
+}
+export declare function parsePriceFeedMessage(message: Buffer): {
+    feedId: Buffer;
+    price: Buffer;
+    confidence: Buffer;
+    exponent: number;
+    publishTime: Buffer;
+    prevPublishTime: Buffer;
+    emaPrice: Buffer;
+    emaConf: Buffer;
+};
+/** parsing of accumulator update data (VAA + updates) */
+export declare function parseAccumulatorUpdateData(data: Buffer): {
+    vaa: Buffer;
+    updates: {
+        message: Buffer;
+        proof: number[][];
+    }[];
+};
+/**
+ * Build instructions to update Pyth price feed accounts (full verification)
+ */
+export declare function buildPythPriceFeedUpdateInstructions(connection: Connection, payer: PublicKey, priceFeedIds: string[], shardId?: number, hermesClient?: HermesClient): Promise<PythUpdateResult>;
+export declare const DEFAULT_COMPUTE_BUDGET_UNITS = 200000;
+/**
+ * The maximum size of a Solana transaction, leaving some room for the compute budget instructions.
+ */
+export declare const PACKET_DATA_SIZE_WITH_ROOM_FOR_COMPUTE_BUDGET: number;
+/**
+ * The maximum number of transactions in a Jito bundle.
+ */
+export declare const JITO_BUNDLE_SIZE = 5;
+export declare const DEFAULT_PRIORITY_FEE_CONFIG: {
+    computeUnitPriceMicroLamports: number;
+};
+/**
+ * Get the size of a transaction that would contain the provided array of instructions
+ */
+export declare function getSizeOfTransaction(instructions: TransactionInstruction[], versionedTransaction?: boolean, addressLookupTable?: {
+    state: {
+        addresses: PublicKey[];
+    };
+}): number;
+/** Get the size of n in bytes when serialized as a CompressedU16 */
+export declare function getSizeOfCompressedU16(n: number): number;
+/**
+ * This class batches instructions into transactions efficiently.
+ */
+export declare class TransactionBuilder {
+    private payer;
+    private connection;
+    private addressLookupTable?;
+    private transactionInstructions;
+    constructor(payer: PublicKey, connection: Connection, addressLookupTable?: {
+        state: {
+            addresses: PublicKey[];
+        };
+    } | undefined);
+    addInstruction(args: {
+        instruction: TransactionInstruction;
+        signers: Signer[];
+        computeUnits?: number;
+    }): void;
+    addInstructions(instructions: {
+        instruction: TransactionInstruction;
+        signers: Signer[];
+        computeUnits?: number;
+    }[]): void;
+    buildVersionedTransactions(args: {
+        computeUnitPriceMicroLamports?: number;
+        tightComputeBudget?: boolean;
+        jitoTipLamports?: number;
+    }): Promise<{
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]>;
+    buildLegacyTransactions(args: {
+        computeUnitPriceMicroLamports?: number;
+        tightComputeBudget?: boolean;
+        jitoTipLamports?: number;
+    }): {
+        tx: Transaction;
+        signers: Signer[];
+    }[];
+    static batchIntoLegacyTransactions(instructions: TransactionInstruction[], priorityFeeConfig: {
+        computeUnitPriceMicroLamports?: number;
+        tightComputeBudget?: boolean;
+        jitoTipLamports?: number;
+    }): Transaction[];
+    static batchIntoVersionedTransactions(payer: PublicKey, connection: Connection, instructions: {
+        instruction: TransactionInstruction;
+        signers: Signer[];
+        computeUnits?: number;
+    }[], priorityFeeConfig: {
+        computeUnitPriceMicroLamports?: number;
+        tightComputeBudget?: boolean;
+        jitoTipLamports?: number;
+    }, addressLookupTable?: {
+        state: {
+            addresses: PublicKey[];
+        };
+    }): Promise<{
+        tx: VersionedTransaction;
+        signers: Signer[];
+    }[]>;
+    static addPriorityFee(transaction: Transaction, priorityFeeConfig: {
+        computeUnitPriceMicroLamports?: number;
+        tightComputeBudget?: boolean;
+        jitoTipLamports?: number;
+    }): void;
+}
+export declare const isVersionedTransaction: (tx: Transaction | VersionedTransaction) => tx is VersionedTransaction;
+/**
+ * Send a set of transactions to the network (with retries), using a plain Signer for the payer
+ */
+export declare function sendTransactions(transactions: {
+    tx: Transaction | VersionedTransaction;
+    signers?: Signer[];
+}[], connection: Connection, payer: Signer, maxRetries?: number): Promise<string[]>;
+export declare function buildPythPriceFeedUpdateTxs(connection: Connection, payer: PublicKey, priceFeedIds: string[], shardId?: number, computeUnitPriceMicroLamports?: number, hermesClient?: HermesClient): Promise<{
+    tx: VersionedTransaction;
+    signers: Signer[];
+}[]>;
 export declare class PriceFeedMessage {
     feedId: Buffer;
     price: BN;