@symmetry-hq/temp-v3-sdk 0.0.1

package/src/layouts/intents/rebalanceIntent.ts

@@ -0,0 +1,111 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { array, publicKey, str, struct, u128, u16, u64, u8 } from '@coral-xyz/borsh';
+import { Fraction, FractionLayout } from "../fraction";
+import { Bounty, BountyLayout } from "./bounty";
+import { OraclePrice } from "../../states/oracles/oracle";
+import { OraclePriceLayout } from "../oracle";
+import { MAX_SUPPORTED_TOKENS_PER_BASKET } from "../basket";
+
+export enum RebalanceType {
+    Deposit,
+    Withdraw,
+    Basket
+};
+
+export enum RebalanceAction {
+    NotActive,
+    DepositTokens,
+    UpdatePrices,
+    AuctionLive
+};
+
+export interface AuctionTimestamps {
+    startTime: BN; // u64
+    endTime: BN; // u64
+};
+
+export const AuctionTimestampsLayout = struct<AuctionTimestamps>([
+    u64('startTime'),
+    u64('endTime'),
+]);
+
+export interface TokenAuction {
+    mint: PublicKey;
+    amount: BN; // u64
+    targetAmount: BN; // u64
+    price: OraclePrice;
+    keepToken: number; // u8
+};
+
+export const TokenAuctionLayout = struct<TokenAuction>([
+    publicKey('mint'),
+    u64('amount'),
+    u64('targetAmount'),
+    OraclePriceLayout.replicate('price'),
+    u8('keepToken'),
+]);
+
+export interface TaskCompletion {
+    completedBounty: BN; //u64
+    completedTime: BN; //u64
+    completedBy: PublicKey; //Pubkey
+};
+
+export const TaskCompletionLayout = struct<TaskCompletion>([
+    u64('completedBounty'),
+    u64('completedTime'),
+    publicKey('completedBy'),
+]);
+
+export interface RebalanceIntent {
+    basket: PublicKey;
+    owner: PublicKey;
+    rentPayer: PublicKey;
+    rebalanceType: RebalanceType;
+    currentAction: RebalanceAction;
+
+    executionStartTime: BN; // u64
+    rebalanceSlippageBps: number; // u16
+    initialTvl: Fraction; // 
+    auctionUpdateTimestamp: BN; // u64
+    auctions: AuctionTimestamps; // AuctionTimestamps[3]
+    tokens: TokenAuction[]; // MAX_SUPPORTED_TOKENS_PER_BASKET
+
+    lastActionTimestamp: BN; // u64
+    bounty: Bounty; // u64
+
+    startPriceUpdateTask: TaskCompletion;
+    priceUpdateTasks: TaskCompletion[]; // MAX_SUPPORTED_TOKENS_PER_BASKET
+    finishPriceUpdateTask: TaskCompletion;
+
+    mintBasketTask: TaskCompletion;
+
+    tokenSettlementTasks: TaskCompletion[]; // MAX_SUPPORTED_TOKENS_PER_BASKET
+};
+
+
+export const RebalanceIntentLayout = struct<RebalanceIntent>([
+    publicKey('basket'),
+    publicKey('owner'),
+    publicKey('rentPayer'),
+    u8('rebalanceType'),
+    u8('currentAction'),
+
+    u64('executionStartTime'),
+    u16('rebalanceSlippageBps'),
+    FractionLayout.replicate('initialTvl'),
+    u64('auctionUpdateTimestamp'),
+    array(AuctionTimestampsLayout, 3, 'auctions'),
+    array(TokenAuctionLayout, MAX_SUPPORTED_TOKENS_PER_BASKET, 'tokens'),
+    u64('lastActionTimestamp'),
+    BountyLayout.replicate('bounty'),
+
+    TaskCompletionLayout.replicate('startPriceUpdateTask'),
+    array(TaskCompletionLayout, MAX_SUPPORTED_TOKENS_PER_BASKET, 'priceUpdateTasks'),
+    TaskCompletionLayout.replicate('finishPriceUpdateTask'),
+
+    TaskCompletionLayout.replicate('mintBasketTask'),
+
+    array(TaskCompletionLayout, MAX_SUPPORTED_TOKENS_PER_BASKET, 'tokenSettlementTasks'),
+]);

package/src/layouts/lookupTable.ts

@@ -0,0 +1,14 @@
+import { publicKey, struct } from '@coral-xyz/borsh';
+import { PublicKey } from '@solana/web3.js';
+
+export interface LookupTableInfo {
+    lookupTable: PublicKey,
+    authority: PublicKey,
+    creator: PublicKey
+};
+
+export const LookupTableInfoLayout = struct<LookupTableInfo>([
+    publicKey("lookupTable"),
+    publicKey("authority"),
+    publicKey("creator")
+]);

package/src/layouts/oracle.ts

@@ -0,0 +1,96 @@
+import { BN } from "@coral-xyz/anchor";
+import { array, publicKey, str, struct, u128, u16, u64, u8 } from '@coral-xyz/borsh';
+import { Fraction, FractionLayout } from "./fraction";
+
+export const MAX_ORACLES_PER_TOKEN = 4;
+export const MAX_ACCOUNTS_PER_ORACLE = 4;
+
+export interface OraclePrice {
+    price: Fraction;
+    conf: Fraction;
+    updateTime: BN; // u64
+};
+
+export const OraclePriceLayout = struct<OraclePrice>([
+    FractionLayout.replicate('price'),
+    FractionLayout.replicate('conf'),
+    u64('updateTime'),
+]);
+
+
+export interface OracleSettings {
+    // type of the oracle (Pyth, CP swap, ...)
+    oracleType: number; // u8
+    numRequiredAccounts: number; // u8
+    // weight used in aggregation
+    weight: number; // u16
+    // whether oracle is required for aggregation
+    isRequired: number; // u8
+    // threshold for confidence ratio (conf / price < threshold)
+    confThreshBps: number; // u16
+    // how old a price can be before it's invalid
+    stalenessThresh: BN; // u64
+    // how much internal price derivations can differ (≥ 1.0)
+    volatilityThreshBps: number; // u16
+    // minimum liquidity (in quote tokens) for valid price
+    minLiquidity: BN; //u64
+    // rate (bps) that inflates confidence with time staleness
+    stalenessConfRateBps: number; // u16
+    tokenDecimals: number; // u8
+    // Special parameters specific to Raydium 
+    twapSecondsAgo: BN; // u64, primary twap window in seconds
+    twapSecondarySecondsAgo: BN; // u64, secondary twap window - to check volatility
+    quote: number; // u8, 1 = USDC, 2 = WSOL
+    side: number; // 0 = base, 1 = quote
+}
+
+export const OracleSettingsLayout = struct<OracleSettings>([
+    u8('oracleType'),
+    u8('numRequiredAccounts'),
+    u16('weight'),
+    u8('isRequired'),
+    u16('confThreshBps'),
+    u64('stalenessThresh'),
+    u16('volatilityThreshBps'),
+    u64('minLiquidity'),
+    u16('stalenessConfRateBps'),
+    u8('tokenDecimals'),
+    u64('twapSecondsAgo'),
+    u64('twapSecondarySecondsAgo'),
+    u8('quote'),
+    u8('side')
+]);
+
+export interface OracleData {
+    oracleSettings: OracleSettings;
+    accountsToLoadLutIds: number[]; // length MAX_ACCOUNTS_PER_ORACLE
+    accountsToLoadLutIndices: number[]; // length MAX_ACCOUNTS_PER_ORACLE
+};
+
+export const OracleDataLayout = struct<OracleData>([
+    OracleSettingsLayout.replicate('oracleSettings'),
+    array(u8(), MAX_ACCOUNTS_PER_ORACLE, 'accountsToLoadLutIds'),
+    array(u8(), MAX_ACCOUNTS_PER_ORACLE, 'accountsToLoadLutIndices'),
+]);
+
+export interface OracleAggregator {
+    numOracles: number; // u8
+    oracles: OracleData[]; // [OracleData; MAX_ORACLES_PER_TOKEN]
+    // minimum confidence ratio allowed (conf / price)
+    minConfBps: number; // u16
+    // maximum confidence ratio allowed (conf / price)
+    confThreshBps: number; // u16
+    // minimum number of oracle results required for valid price
+    minOraclesThresh: number; // u8
+    // factor to expand confidence bands (≥ 1.0)
+    confMultiplier: Fraction;
+}
+
+export const OracleAggregatorLayout = struct<OracleAggregator>([
+    u8('numOracles'),
+    array(OracleDataLayout, MAX_ORACLES_PER_TOKEN, 'oracles'),
+    u16('minConfBps'),
+    u16('confThreshBps'),
+    u8('minOraclesThresh'),
+    FractionLayout.replicate('confMultiplier')
+]);

package/src/states/basket.ts

@@ -0,0 +1,56 @@
+import { Connection, GetProgramAccountsFilter, GetProgramAccountsResponse, PublicKey } from "@solana/web3.js";
+import { AssetLayout, Basket, BasketLayout, LookupTablesLayout } from "../layouts/basket";
+import { BASKETS_V3_PROGRAM_ID } from "../constants";
+
+
+export async function fetchBasket(
+    connection: Connection,
+    basketAddress: PublicKey,
+): Promise<Basket> {
+    const basketAi = await connection.getAccountInfo(basketAddress);
+    if (!basketAi) {
+        throw new Error("Basket not found");
+    }
+    return BasketLayout.decode(basketAi.data.slice(8));
+}
+
+export interface BasketFilter {
+    filterType: "host" | "creator";
+    filterValue: PublicKey;
+}
+
+export async function fetchBaskets(
+    connection: Connection,
+    filters: BasketFilter[],
+): Promise<Basket[]> {
+    console.log("fetching baskets with size", BasketLayout.getSpan());
+    let accountFilters: GetProgramAccountsFilter[] = [
+        { dataSize: 8 + BasketLayout.getSpan() },
+    ];
+    for (const filter of filters) {
+        if (filter.filterType === "host") {
+            accountFilters.push({ memcmp: {
+                offset: 8 + 1 + 16 + 32 + 32 + 8 + 16 + 8,
+                bytes: filter.filterValue.toBase58()
+            } });
+        } else if (filter.filterType === "creator") {
+            accountFilters.push({ memcmp: {
+                offset: 8 + 1 + 16 + 32 + 32 + 8 + 16 + 8 + 32,
+                bytes: filter.filterValue.toBase58()
+            } });
+        }
+    }
+    const accounts: GetProgramAccountsResponse = await connection
+        .getProgramAccounts(
+            BASKETS_V3_PROGRAM_ID,
+            {
+                commitment: "confirmed",
+                filters: accountFilters,
+                encoding: 'base64'
+            }
+        );
+    const baskets: Basket[] = accounts.map(account => 
+        BasketLayout.decode(account.account.data.slice(8))
+    );
+    return baskets;
+}

package/src/states/intents/intent.ts

@@ -0,0 +1,107 @@
+import { BN } from '@coral-xyz/anchor';
+import { array, publicKey, struct, u16, u32, u64, u8 } from '@coral-xyz/borsh';
+import { Connection, PublicKey } from '@solana/web3.js';
+
+import { BASKETS_V3_PROGRAM_ID } from '../../constants';
+import { AddTokenDelayLayout, AddTokenLayout, Intent, IntentLayout, IntentStatus, ManagerSettingsWithAuthorityBitmasksLayout, ParsedIntent, SwapLayout, TaskType, UpdateWeightsDelayLayout, UpdateWeightsLayout } from '../../layouts/intents/intent';
+import { MetadataSettingsLayout, AutomationSettingsLayout, FeeSettingsLayout, LpSettingsLayout, ScheduleSettingsLayout } from '../../layouts/config';
+import { GetProgramAccountsFilter } from '@solana/web3.js';
+import { GetProgramAccountsResponse } from '@solana/web3.js';
+
+// Map task type -> layout used to decode taskData prefix
+const taskLayoutMap = new Map<number, any>([
+  [TaskType.EditSchedule, ScheduleSettingsLayout],
+  [TaskType.EditFeeSettings, FeeSettingsLayout],
+  [TaskType.EditManagerSettings, ManagerSettingsWithAuthorityBitmasksLayout],
+  [TaskType.EditAutomationSettings, AutomationSettingsLayout],
+  [TaskType.EditLpSettings, LpSettingsLayout],
+  [TaskType.EditMetadataSettings, MetadataSettingsLayout],
+  [TaskType.EditAddTokenDelay, AddTokenDelayLayout],
+  [TaskType.EditUpdateWeightsDelay, UpdateWeightsDelayLayout],
+  [TaskType.AddToken, AddTokenLayout],
+  [TaskType.UpdateWeights, UpdateWeightsLayout],
+  [TaskType.Swap, SwapLayout],
+]);
+
+// Decode taskData buffer for a given task type; returns decoded object or raw Buffer on failure
+
+function decodeTaskDataForType(
+    taskType: TaskType, 
+    taskData: number[]
+): any {
+    const layout = taskLayoutMap.get(taskType);
+    return layout.decode(taskData);
+};
+
+
+/**
+ * Decode an Intent account buffer.
+ * Returns ParsedIntent.
+ */
+export function decodeIntent(intent: Intent): ParsedIntent {
+    let parsedTaskData = decodeTaskDataForType(intent.taskType, intent.taskData);
+    return {
+        ...intent,
+        taskData: parsedTaskData,
+    };
+}
+
+export async function fetchIntent(
+    connection: Connection,
+    intent: PublicKey,
+): Promise<Intent>{
+    const intentAi = await connection.getAccountInfo(
+        intent
+    );
+    if (!intentAi) throw new Error('Basket intent not found');
+    return IntentLayout.decode(intentAi.data.slice(8));
+}
+
+export async function fetchParsedIntent(
+    connection: Connection,
+    intent: PublicKey,
+): Promise<ParsedIntent>{
+    const intentState: Intent = await fetchIntent(connection, intent);
+    return decodeIntent(intentState);
+}
+
+export interface IntentFilter {
+    filterType: "basket" | "owner";
+    filterValue: PublicKey;
+}
+
+export async function fetchIntents(
+    connection: Connection,
+    filters: IntentFilter[],
+): Promise<Intent[]> {
+    console.log("fetching intents with size", IntentLayout.getSpan());
+    let accountFilters: GetProgramAccountsFilter[] = [
+        { dataSize: 8 + IntentLayout.getSpan() },
+    ];
+    for (const filter of filters) {
+        if (filter.filterType === "basket") {
+            accountFilters.push({ memcmp: {
+                offset: 8 + 32 + 1 + 8,
+                bytes: filter.filterValue.toBase58()
+            } });
+        } else if (filter.filterType === "owner") {
+            accountFilters.push({ memcmp: {
+                offset: 8,
+                bytes: filter.filterValue.toBase58()
+            } });
+        }
+    }
+    const accounts: GetProgramAccountsResponse = await connection
+        .getProgramAccounts(
+            BASKETS_V3_PROGRAM_ID,
+            {
+                commitment: "confirmed",
+                filters: accountFilters,
+                encoding: 'base64'
+            }
+        );
+    const rebalanceIntents: Intent[] = accounts.map(account => 
+        IntentLayout.decode(account.account.data.slice(8))
+    );
+    return rebalanceIntents;
+}

package/src/states/intents/rebalanceIntent.ts

@@ -0,0 +1,57 @@
+import { Connection, GetProgramAccountsResponse, PublicKey } from "@solana/web3.js";
+import { RebalanceIntent, RebalanceIntentLayout } from "../../layouts/intents/rebalanceIntent";
+import { GetProgramAccountsFilter } from "@solana/web3.js";
+import { BASKETS_V3_PROGRAM_ID } from "../../constants";
+
+
+export async function fetchRebalanceIntent(
+    connection: Connection,
+    rebalanceIntent: PublicKey,
+): Promise<RebalanceIntent> {
+    const rebalanceIntentAi = await connection.getAccountInfo(rebalanceIntent);
+    if (!rebalanceIntentAi) {
+        throw new Error("Rebalance intent not found");
+    }
+    return RebalanceIntentLayout.decode(rebalanceIntentAi.data.slice(8));
+}
+
+export interface RebalanceIntentFilter {
+    filterType: "basket" | "owner";
+    filterValue: PublicKey;
+}
+
+export async function fetchRebalanceIntents(
+    connection: Connection,
+    filters: RebalanceIntentFilter[],
+): Promise<RebalanceIntent[]> {
+    console.log("fetching rebalance intents with size", RebalanceIntentLayout.getSpan());
+    let accountFilters: GetProgramAccountsFilter[] = [
+        { dataSize: 8 + RebalanceIntentLayout.getSpan() },
+    ];
+    for (const filter of filters) {
+        if (filter.filterType === "basket") {
+            accountFilters.push({ memcmp: {
+                offset: 8,
+                bytes: filter.filterValue.toBase58()
+            } });
+        } else if (filter.filterType === "owner") {
+            accountFilters.push({ memcmp: {
+                offset: 8 + 32,
+                bytes: filter.filterValue.toBase58()
+            } });
+        }
+    }
+    const accounts: GetProgramAccountsResponse = await connection
+        .getProgramAccounts(
+            BASKETS_V3_PROGRAM_ID,
+            {
+                commitment: "confirmed",
+                filters: accountFilters,
+                encoding: 'base64'
+            }
+        );
+    const rebalanceIntents: RebalanceIntent[] = accounts.map(account => 
+        RebalanceIntentLayout.decode(account.account.data.slice(8))
+    );
+    return rebalanceIntents;
+}

package/src/states/oracles/constants.ts

@@ -0,0 +1,13 @@
+import { BN } from "@coral-xyz/anchor";
+
+
+export const U8_MAX = new BN(0xff);
+export const U16_MAX = new BN(0xffff);
+export const U32_MAX = new BN(0xffffffff);
+export const U64_MAX = new BN(1).shln(64).sub(new BN(1));
+export const U128_MAX = new BN(1).shln(128).sub(new BN(1));
+
+
+export const HERMES_PUBLIC_ENDPOINT = "https://hermes.pyth.network";
+export const SOLANA_DEVNET_ENDPOINT = "https://api.devnet.solana.com";
+export const SOLANA_MAINNET_ENDPOINT = "https://api.mainnet-beta.solana.com";