@symmetry-hq/sdk 1.0.1

package/dist/src/instructions/pda.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_METADATA_PROGRAM_ID = exports.REBALANCE_INTENT_SEED = exports.BOUNTY_VAULT_SEED = exports.RENT_PAYER_SEED = exports.MINT_SEED = exports.BASKET_SEED = exports.WITHDRAW_BASKET_FEES_SEED = exports.BASKET_FEES_SEED = exports.GLOBAL_CONFIG_SEED = void 0;
+exports.serializeString = serializeString;
+exports.getRandomSeed = getRandomSeed;
+exports.getBasketTokenMintPda = getBasketTokenMintPda;
+exports.getBasketState = getBasketState;
+exports.getBountyVaultPda = getBountyVaultPda;
+exports.getBasketFeesPda = getBasketFeesPda;
+exports.getWithdrawBasketFeesPda = getWithdrawBasketFeesPda;
+exports.getGlobalConfigPda = getGlobalConfigPda;
+exports.getRentPayerPda = getRentPayerPda;
+exports.getIntentPda = getIntentPda;
+exports.getRebalanceIntentPda = getRebalanceIntentPda;
+exports.getMetadataAccount = getMetadataAccount;
+exports.getLookupTableAccount = getLookupTableAccount;
+exports.getLookupTableInfoAccount = getLookupTableInfoAccount;
+exports.getAta = getAta;
+const crypto_1 = require("crypto");
+const bn_js_1 = __importDefault(require("bn.js"));
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../constants");
+exports.GLOBAL_CONFIG_SEED = Buffer.from("global_config");
+exports.BASKET_FEES_SEED = Buffer.from("basket_fees");
+exports.WITHDRAW_BASKET_FEES_SEED = Buffer.from("withdraw_basket_fees");
+exports.BASKET_SEED = Buffer.from("basket");
+exports.MINT_SEED = Buffer.from("mint");
+exports.RENT_PAYER_SEED = Buffer.from("rent_payer");
+exports.BOUNTY_VAULT_SEED = Buffer.from("bounty_vault");
+exports.REBALANCE_INTENT_SEED = Buffer.from("rebalance_intent");
+exports.TOKEN_METADATA_PROGRAM_ID = new web3_js_1.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+function serializeString(input) {
+    const utf8 = new TextEncoder().encode(input);
+    const length = utf8.length;
+    const out = new Uint8Array(4 + length);
+    // encode length as little-endian u32
+    out[0] = length & 0xff;
+    out[1] = (length >> 8) & 0xff;
+    out[2] = (length >> 16) & 0xff;
+    out[3] = (length >> 24) & 0xff;
+    // copy utf8 bytes after the 4-byte length
+    out.set(utf8, 4);
+    return out;
+}
+function getRandomSeed() {
+    return Array.from((0, crypto_1.randomBytes)(16));
+}
+function getBasketTokenMintPda(basketId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.MINT_SEED,
+        new bn_js_1.default(basketId).toArrayLike(Buffer, "le", 8)
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getBasketState(mint) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.BASKET_SEED,
+        mint.toBuffer()
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getBountyVaultPda() {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.BOUNTY_VAULT_SEED,
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getBasketFeesPda(basket) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.BASKET_FEES_SEED,
+        basket.toBuffer()
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getWithdrawBasketFeesPda(basket, feeType) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.WITHDRAW_BASKET_FEES_SEED,
+        basket.toBuffer(),
+        Buffer.from([feeType]) // u8, not u64
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getGlobalConfigPda() {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.GLOBAL_CONFIG_SEED
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getRentPayerPda() {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.RENT_PAYER_SEED
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getIntentPda(basket, intentSeedArray, editType) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        basket.toBuffer(),
+        intentSeedArray,
+        Uint8Array.from([editType]),
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getRebalanceIntentPda(basket, owner) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        exports.REBALANCE_INTENT_SEED,
+        basket.toBuffer(),
+        owner.toBuffer(),
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getMetadataAccount(tokenMint) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from("metadata"),
+        exports.TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+        tokenMint.toBuffer(),
+    ], exports.TOKEN_METADATA_PROGRAM_ID)[0];
+}
+function getLookupTableAccount(creator, slot) {
+    const ixAndPubkey = web3_js_1.AddressLookupTableProgram.createLookupTable({
+        authority: creator,
+        recentSlot: slot,
+        payer: creator,
+    });
+    return ixAndPubkey[1];
+}
+function getLookupTableInfoAccount(lookupTable) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        lookupTable.toBuffer()
+    ], constants_1.BASKETS_V3_PROGRAM_ID)[0];
+}
+function getAta(wallet, tokenMint, tokenProgram) {
+    return (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, wallet, true, tokenProgram);
+}

package/dist/src/instructions/user/deposit.d.ts

@@ -0,0 +1,20 @@
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+export declare function depositTokensIx(params: {
+    owner: PublicKey;
+    basket: PublicKey;
+    contributions: {
+        mint: PublicKey;
+        amount: number;
+    }[];
+}): TransactionInstruction[];
+export declare function lockDepositsIx(params: {
+    owner: PublicKey;
+    basket: PublicKey;
+}): TransactionInstruction;
+export declare function mintBasketIx(params: {
+    keeper: PublicKey;
+    basket: PublicKey;
+    basketTokenMint: PublicKey;
+    buyer: PublicKey;
+    basketRebalanceIntent?: PublicKey;
+}): TransactionInstruction;

package/dist/src/instructions/user/deposit.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depositTokensIx = depositTokensIx;
+exports.lockDepositsIx = lockDepositsIx;
+exports.mintBasketIx = mintBasketIx;
+const bn_js_1 = __importDefault(require("bn.js"));
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../../constants");
+const pda_1 = require("../pda");
+const DEPOSIT_TOKENS_DISCRIMINATOR = Buffer.from([88, 92, 158, 219, 83, 71, 239, 164]);
+const LOCK_DEPOSITS_DISCRIMINATOR = Buffer.from([64, 238, 171, 198, 135, 253, 37, 9]);
+const MINT_BASKET_DISCRIMINATOR = Buffer.from([161, 207, 48, 45, 7, 156, 233, 143]);
+function depositTokensIx(params) {
+    const { owner, basket, contributions } = params;
+    let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, owner);
+    const discriminator = DEPOSIT_TOKENS_DISCRIMINATOR;
+    let ixs = [];
+    let batch_size = 5;
+    for (let i = 0; i < contributions.length; i += batch_size) {
+        let batch_contributions = contributions.slice(i, i + batch_size);
+        let amounts = batch_contributions.map((contribution) => contribution.amount);
+        while (amounts.length < 10)
+            amounts.push(0);
+        const amountsBuffer = Buffer.concat(amounts.map((amount) => Buffer.from(new bn_js_1.default(amount).toArray("le", 8))));
+        const data = Buffer.concat([discriminator, amountsBuffer]);
+        const keys = [
+            { pubkey: owner, isSigner: true, isWritable: true },
+            { pubkey: basket, isSigner: false, isWritable: true },
+            { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+        ];
+        // remaining accounts
+        batch_contributions.forEach((contribution) => {
+            let mint = contribution.mint;
+            let ownerAta = (0, pda_1.getAta)(owner, mint);
+            let basketAta = (0, pda_1.getAta)(basket, mint);
+            keys.push({ pubkey: mint, isSigner: false, isWritable: false });
+            keys.push({ pubkey: ownerAta, isSigner: false, isWritable: true });
+            keys.push({ pubkey: basketAta, isSigner: false, isWritable: true });
+        });
+        ixs.push(new web3_js_1.TransactionInstruction({
+            keys,
+            programId: constants_1.BASKETS_V3_PROGRAM_ID,
+            data,
+        }));
+    }
+    return ixs;
+}
+function lockDepositsIx(params) {
+    const { owner, basket } = params;
+    let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, owner);
+    let globalConfig = (0, pda_1.getGlobalConfigPda)();
+    const keys = [
+        { pubkey: params.owner, isSigner: true, isWritable: true },
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: globalConfig, isSigner: false, isWritable: false },
+    ];
+    return new web3_js_1.TransactionInstruction({
+        keys,
+        programId: constants_1.BASKETS_V3_PROGRAM_ID,
+        data: LOCK_DEPOSITS_DISCRIMINATOR,
+    });
+}
+function mintBasketIx(params) {
+    var _a;
+    const { keeper, basket, basketTokenMint, buyer } = params;
+    let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, buyer);
+    let basketFees = (0, pda_1.getBasketFeesPda)(basket);
+    let globalConfig = (0, pda_1.getGlobalConfigPda)();
+    let buyerBasketATA = (0, pda_1.getAta)(buyer, basketTokenMint);
+    let basketFeesAta = (0, pda_1.getAta)(basketFees, basketTokenMint);
+    const keys = [
+        { pubkey: keeper, isWritable: true, isSigner: true },
+        { pubkey: basket, isWritable: true, isSigner: false },
+        { pubkey: rebalanceIntent, isWritable: true, isSigner: false },
+        { pubkey: basketTokenMint, isWritable: true, isSigner: false },
+        { pubkey: buyer, isWritable: true, isSigner: false },
+        { pubkey: buyerBasketATA, isWritable: true, isSigner: false },
+        { pubkey: globalConfig, isWritable: false, isSigner: false },
+        { pubkey: basketFees, isWritable: true, isSigner: false },
+        { pubkey: basketFeesAta, isWritable: true, isSigner: false },
+        { pubkey: (_a = params.basketRebalanceIntent) !== null && _a !== void 0 ? _a : constants_1.BASKETS_V3_PROGRAM_ID, isWritable: params.basketRebalanceIntent ? true : false, isSigner: false },
+        { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+        { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isWritable: false, isSigner: false },
+        { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+        { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
+    ];
+    return new web3_js_1.TransactionInstruction({
+        keys,
+        programId: constants_1.BASKETS_V3_PROGRAM_ID,
+        data: MINT_BASKET_DISCRIMINATOR,
+    });
+}

package/dist/src/instructions/user/withdraw.d.ts

@@ -0,0 +1,8 @@
+import { PublicKey } from "@solana/web3.js";
+import { TransactionInstruction } from "@solana/web3.js";
+export declare function redeemTokensIx(params: {
+    keeper: PublicKey;
+    basket: PublicKey;
+    owner: PublicKey;
+    tokenMints: PublicKey[];
+}): TransactionInstruction;

package/dist/src/instructions/user/withdraw.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeemTokensIx = redeemTokensIx;
+const constants_1 = require("../../constants");
+const spl_token_1 = require("@solana/spl-token");
+const pda_1 = require("../pda");
+const web3_js_1 = require("@solana/web3.js");
+const web3_js_2 = require("@solana/web3.js");
+const REDEEM_TOKENS_DISCRIMINATOR = Buffer.from([83, 49, 112, 2, 105, 193, 106, 126]);
+function redeemTokensIx(params) {
+    const { keeper, basket, owner, } = params;
+    let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, owner);
+    const keys = [
+        { pubkey: keeper, isSigner: true, isWritable: true },
+        { pubkey: basket, isSigner: false, isWritable: true },
+        { pubkey: rebalanceIntent, isSigner: false, isWritable: true },
+        { pubkey: owner, isSigner: false, isWritable: true },
+        { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: web3_js_2.SystemProgram.programId, isSigner: false, isWritable: false },
+    ];
+    // remaining accounts
+    params.tokenMints.forEach((mint) => {
+        keys.push({ pubkey: mint, isWritable: false, isSigner: false });
+        keys.push({ pubkey: (0, pda_1.getAta)(owner, mint), isWritable: true, isSigner: false });
+        keys.push({ pubkey: (0, pda_1.getAta)(basket, mint), isWritable: true, isSigner: false });
+    });
+    const discriminator = REDEEM_TOKENS_DISCRIMINATOR;
+    const data = discriminator;
+    return new web3_js_1.TransactionInstruction({
+        keys,
+        programId: constants_1.BASKETS_V3_PROGRAM_ID,
+        data,
+    });
+}

package/dist/src/jup.d.ts

@@ -0,0 +1,49 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare function processJupInstruction(instruction: {
+    programId: string;
+    accounts: {
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }[];
+    data: string;
+}): TransactionInstruction;
+export declare function getJupQuote(params: {
+    keeper: PublicKey;
+    basketMintIn: PublicKey;
+    basketMintOut: PublicKey;
+    basketAmountIn: number;
+    basketAmountOut: number;
+    swapMode: "exact_in" | "exact_out" | "ioc";
+    apiKey: string;
+    maxJupAccounts: number;
+}): Promise<{
+    mode: string;
+    inputMint: string;
+    outputMint: string;
+    inAmount: number;
+    outAmount: number;
+    swapUsdValue: number;
+    routePlan: any;
+    transaction: string;
+}>;
+export declare function getJupSwapInstructions(params: {
+    keeper: PublicKey;
+    quoteResponse: any;
+    apiKey: string;
+}): Promise<any>;
+export declare function getJupTokenLedgerAndSwapInstructions(params: {
+    keeper: PublicKey;
+    basketMintIn: PublicKey;
+    basketMintOut: PublicKey;
+    basketAmountIn: number;
+    basketAmountOut: number;
+    swapMode: "exact_in" | "exact_out" | "ioc";
+    apiKey: string;
+    maxJupAccounts: number;
+}): Promise<{
+    tokenLedgerInstruction: TransactionInstruction;
+    swapInstruction: TransactionInstruction;
+    addressLookupTableAddresses: PublicKey[];
+    quoteResponse: any;
+}>;

package/dist/src/jup.js

@@ -0,0 +1,80 @@
+"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.processJupInstruction = processJupInstruction;
+exports.getJupQuote = getJupQuote;
+exports.getJupSwapInstructions = getJupSwapInstructions;
+exports.getJupTokenLedgerAndSwapInstructions = getJupTokenLedgerAndSwapInstructions;
+const web3_js_1 = require("@solana/web3.js");
+function processJupInstruction(instruction) {
+    return {
+        programId: new web3_js_1.PublicKey(instruction.programId),
+        keys: instruction.accounts.map((a) => (Object.assign(Object.assign({}, a), { pubkey: new web3_js_1.PublicKey(a.pubkey) }))),
+        data: Buffer.from(instruction.data, "base64")
+    };
+}
+function getJupQuote(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let options = { method: 'GET', headers: { 'x-api-key': params.apiKey } };
+        let reqUrl = 'https://api.jup.ag/swap/v1/quote' +
+            '?inputMint=' + params.basketMintOut.toBase58() +
+            '&outputMint=' + params.basketMintIn.toBase58() +
+            '&amount=' + (params.swapMode == "exact_in" ? params.basketAmountIn : params.basketAmountOut) +
+            '&swapMode=' + (params.swapMode == "exact_in" ? "ExactOut" : "ExactIn") +
+            '&maxAccounts=' + params.maxJupAccounts;
+        let res = yield fetch(reqUrl, options).then(res => res.json());
+        return res;
+    });
+}
+function getJupSwapInstructions(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let reqUrl = 'https://api.jup.ag/swap/v1/swap-instructions';
+        let body = {
+            userPublicKey: params.keeper.toBase58(),
+            quoteResponse: params.quoteResponse,
+            wrapAndUnwrapSol: false,
+            useTokenLedger: true,
+        };
+        let options = {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': params.apiKey
+            },
+            body: JSON.stringify(body),
+        };
+        let res = yield fetch(reqUrl, options).then(res => res.json());
+        return res;
+    });
+}
+function getJupTokenLedgerAndSwapInstructions(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let quoteResponse = yield getJupQuote(params);
+            let swapInstructions = yield getJupSwapInstructions(Object.assign(Object.assign({}, params), { quoteResponse }));
+            return {
+                tokenLedgerInstruction: processJupInstruction(swapInstructions.tokenLedgerInstruction),
+                swapInstruction: processJupInstruction(swapInstructions.swapInstruction),
+                addressLookupTableAddresses: swapInstructions.addressLookupTableAddresses.map((a) => new web3_js_1.PublicKey(a)),
+                quoteResponse: quoteResponse,
+            };
+        }
+        catch (e) {
+            console.log("Error getting Jup Instructions:", params.basketMintOut.toBase58(), params.basketMintIn.toBase58(), params.basketAmountOut);
+            return {
+                tokenLedgerInstruction: undefined,
+                swapInstruction: undefined,
+                addressLookupTableAddresses: [],
+                quoteResponse: undefined,
+            };
+        }
+    });
+}

package/dist/src/keeperMonitor.d.ts

@@ -0,0 +1,52 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Wallet } from "./txUtils";
+import { Basket, UIRebalanceIntent } from ".";
+export declare class KeeperMonitor {
+    private params;
+    private intents;
+    private rebalanceIntents;
+    private baskets;
+    constructor(params: {
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    });
+    delay: (ms: number) => Promise<unknown>;
+    update(): Promise<void>;
+    run(runTime?: number): Promise<void>;
+    monitorIntent(pubkey: string): Promise<void>;
+    monitorRebalanceIntent(pubkey: string): Promise<void>;
+}
+export declare class RebalanceHandler {
+    private params;
+    private intent;
+    private basket;
+    constructor(params: {
+        intent: UIRebalanceIntent;
+        basket: Basket;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    });
+    delay: (ms: number) => Promise<unknown>;
+    refresh(): Promise<void>;
+    static run(params: {
+        intentPubkey: PublicKey;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    }): Promise<void>;
+    private execute;
+}