@quartz-labs/sdk 0.0.1 → 0.0.3

package/dist/user.js

@@ -0,0 +1,158 @@
+import { PublicKey, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY } from "@solana/web3.js";
+import { DriftUser } from "./model/driftUser";
+import { BN, DRIFT_PROGRAM_ID } from "@drift-labs/sdk";
+import { getDriftSpotMarketPublicKey, getDriftStatePublicKey, getVaultPublicKey, getVaultSplPublicKey } from "./utils/helpers";
+import { DRIFT_MARKET_INDEX_SOL, DRIFT_MARKET_INDEX_USDC, QUARTZ_HEALTH_BUFFER, USDC_MINT, WSOL_MINT } from "./config/constants";
+import { TOKEN_PROGRAM_ID } from "@coral-xyz/anchor/dist/cjs/utils/token";
+import { ASSOCIATED_TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { SwapMode } from "@jup-ag/api";
+import { getJupiterSwapIx } from "./utils/jupiter";
+export class QuartzUser {
+    constructor(pubkey, connection, program, quartzLookupTable, oracles, driftClient, driftUserAccount) {
+        this.pubkey = pubkey;
+        this.vaultPubkey = getVaultPublicKey(pubkey);
+        this.connection = connection;
+        this.program = program;
+        this.quartzLookupTable = quartzLookupTable;
+        this.oracles = oracles;
+        this.driftClient = driftClient;
+        this.driftUser = new DriftUser(this.vaultPubkey, connection, driftClient, driftUserAccount);
+    }
+    convertToQuartzHealth(protocolHealth) {
+        if (protocolHealth <= 0)
+            return 0;
+        if (protocolHealth >= 100)
+            return 100;
+        return Math.floor(Math.min(100, Math.max(0, (protocolHealth - QUARTZ_HEALTH_BUFFER) / (1 - QUARTZ_HEALTH_BUFFER))));
+    }
+    getHealth() {
+        const driftHealth = this.driftUser.getHealth();
+        return this.convertToQuartzHealth(driftHealth);
+    }
+    getRepayAmountForTargetHealth(targetHealth, repayCollateralWeight) {
+        // New Quartz health after repayment is given as:
+        // 
+        //                                           loanValue - repayAmount                     
+        //                  1 - ----------------------------------------------------------------- - quartzHealthBuffer
+        //                      currentWeightedCollateral - (repayAmount * repayCollateralWeight)
+        //   targetHealth = -------------------------------------------------------------------------------------------
+        //                                                    1 - quartzHealthBuffer                                  
+        //
+        // The following is an algebraicly simplified expression of the above formula, in terms of repayAmount
+        if (targetHealth <= 0 || targetHealth >= 100)
+            throw Error(`Target health must be between 0 and 100`);
+        if (targetHealth <= this.getHealth())
+            throw Error(`Target health must be greater than current health`);
+        const currentWeightedCollateral = this.getTotalWeightedCollateral();
+        const loanValue = this.getMaintenanceMarginRequirement();
+        return Math.round((loanValue - currentWeightedCollateral * (1 - QUARTZ_HEALTH_BUFFER) * (1 - targetHealth)) / (1 - repayCollateralWeight * (1 - QUARTZ_HEALTH_BUFFER) * (1 - targetHealth)));
+    }
+    getTotalWeightedCollateral() {
+        return this.driftUser.getTotalCollateral('Maintenance').toNumber();
+    }
+    getMaintenanceMarginRequirement() {
+        return this.driftUser.getMaintenanceMarginRequirement().toNumber();
+    }
+    async makeCollateralRepayIxs(caller, callerDepositSpl, callerWithdrawSpl, callerStartingDepositBalance, jupiterExactOutRouteQuote) {
+        const depositMint = USDC_MINT;
+        const depositMarketIndex = DRIFT_MARKET_INDEX_USDC;
+        const withdrawMint = WSOL_MINT;
+        const withdrawMarketIndex = DRIFT_MARKET_INDEX_SOL;
+        if (jupiterExactOutRouteQuote.swapMode !== SwapMode.ExactOut)
+            throw Error("Jupiter quote must be ExactOutRoute");
+        if (jupiterExactOutRouteQuote.inputMint !== withdrawMint.toBase58())
+            throw Error("Jupiter quote inputMint does not match withdrawMint");
+        if (jupiterExactOutRouteQuote.outputMint !== depositMint.toBase58())
+            throw Error("Jupiter quote outputMint does not match depositMint");
+        const driftState = getDriftStatePublicKey();
+        const driftSpotMarketDeposit = getDriftSpotMarketPublicKey(depositMarketIndex);
+        const driftSpotMarketWithdraw = getDriftSpotMarketPublicKey(withdrawMarketIndex);
+        const autoRepayStartPromise = this.program.methods
+            .autoRepayStart(new BN(callerStartingDepositBalance))
+            .accounts({
+            caller: caller,
+            callerWithdrawSpl: callerWithdrawSpl,
+            withdrawMint: withdrawMint,
+            vault: this.vaultPubkey,
+            vaultWithdrawSpl: getVaultSplPublicKey(this.vaultPubkey, withdrawMint),
+            owner: this.pubkey,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+            instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
+        })
+            .instruction();
+        const jupiterSwapPromise = getJupiterSwapIx(caller, this.connection, jupiterExactOutRouteQuote);
+        const autoRepayDepositPromise = this.program.methods
+            .autoRepayDeposit(depositMarketIndex)
+            .accounts({
+            vault: this.vaultPubkey,
+            vaultSpl: getVaultSplPublicKey(this.vaultPubkey, depositMint),
+            owner: this.pubkey,
+            caller: caller,
+            callerSpl: callerDepositSpl,
+            splMint: depositMint,
+            driftUser: this.driftUser.pubkey,
+            driftUserStats: this.driftUser.statsPubkey,
+            driftState: driftState,
+            spotMarketVault: driftSpotMarketDeposit,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            driftProgram: new PublicKey(DRIFT_PROGRAM_ID),
+            systemProgram: SystemProgram.programId,
+            instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
+        })
+            .remainingAccounts(this.driftClient.getRemainingAccounts({
+            userAccounts: [this.driftUser.getDriftUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [depositMarketIndex],
+        }))
+            .instruction();
+        const autoRepayWithdrawPromise = this.program.methods
+            .autoRepayWithdraw(withdrawMarketIndex)
+            .accounts({
+            vault: this.vaultPubkey,
+            vaultSpl: getVaultSplPublicKey(this.vaultPubkey, withdrawMint),
+            owner: this.pubkey,
+            caller: caller,
+            callerSpl: callerWithdrawSpl,
+            splMint: withdrawMint,
+            driftUser: this.driftUser.pubkey,
+            driftUserStats: this.driftUser.statsPubkey,
+            driftState: driftState,
+            spotMarketVault: driftSpotMarketWithdraw,
+            driftSigner: this.driftClient.getSignerPublicKey(),
+            tokenProgram: TOKEN_PROGRAM_ID,
+            driftProgram: DRIFT_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+            depositPriceUpdate: this.oracles.get("USDC/USD"),
+            withdrawPriceUpdate: this.oracles.get("SOL/USD"),
+            instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
+        })
+            .remainingAccounts(this.driftClient.getRemainingAccounts({
+            userAccounts: [this.driftUser.getDriftUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [withdrawMarketIndex],
+            readableSpotMarketIndexes: [DRIFT_MARKET_INDEX_USDC], // Quote is in USDC
+        }))
+            .instruction();
+        const [ix_autoRepayStart, { ix_jupiterSwap, jupiterLookupTables }, ix_autoRepayDeposit, ix_autoRepayWithdraw] = await Promise.all([
+            autoRepayStartPromise,
+            jupiterSwapPromise,
+            autoRepayDepositPromise,
+            autoRepayWithdrawPromise
+        ]);
+        return {
+            ixs: [
+                ix_autoRepayStart,
+                ix_jupiterSwap,
+                ix_autoRepayDeposit,
+                ix_autoRepayWithdraw
+            ],
+            lookupTables: [
+                this.quartzLookupTable,
+                ...jupiterLookupTables
+            ],
+        };
+    }
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const getVaultPublicKey: (user: PublicKey) => PublicKey;
+export declare const getVaultSplPublicKey: (user: PublicKey, mint: PublicKey) => PublicKey;
+export declare const getDriftUserPublicKey: (vaultPda: PublicKey) => PublicKey;
+export declare const getDriftUserStatsPublicKey: (vaultPda: PublicKey) => PublicKey;
+export declare const getDriftStatePublicKey: () => PublicKey;
+export declare const getDriftSpotMarketPublicKey: (marketIndex: number) => PublicKey;
+export declare const toRemainingAccount: (pubkey: PublicKey, isWritable: boolean, isSigner: boolean) => {
+    pubkey: PublicKey;
+    isWritable: boolean;
+    isSigner: boolean;
+};

package/dist/utils/helpers.js

@@ -0,0 +1,39 @@
+import { PublicKey } from "@solana/web3.js";
+import { QUARTZ_PROGRAM_ID } from "../config/constants";
+import { BN } from "@coral-xyz/anchor";
+import { DRIFT_PROGRAM_ID } from "@drift-labs/sdk";
+export const getVaultPublicKey = (user) => {
+    const [vaultPda] = PublicKey.findProgramAddressSync([Buffer.from("vault"), user.toBuffer()], QUARTZ_PROGRAM_ID);
+    return vaultPda;
+};
+export const getVaultSplPublicKey = (user, mint) => {
+    const vaultPda = getVaultPublicKey(user);
+    const [vaultSplPda] = PublicKey.findProgramAddressSync([vaultPda.toBuffer(), mint.toBuffer()], QUARTZ_PROGRAM_ID);
+    return vaultSplPda;
+};
+export const getDriftUserPublicKey = (vaultPda) => {
+    const [userPda] = PublicKey.findProgramAddressSync([
+        Buffer.from("user"),
+        vaultPda.toBuffer(),
+        new BN(0).toArrayLike(Buffer, 'le', 2),
+    ], new PublicKey(DRIFT_PROGRAM_ID));
+    return userPda;
+};
+export const getDriftUserStatsPublicKey = (vaultPda) => {
+    const [userStatsPda] = PublicKey.findProgramAddressSync([Buffer.from("user_stats"), vaultPda.toBuffer()], new PublicKey(DRIFT_PROGRAM_ID));
+    return userStatsPda;
+};
+export const getDriftStatePublicKey = () => {
+    const [statePda] = PublicKey.findProgramAddressSync([Buffer.from("drift_state")], new PublicKey(DRIFT_PROGRAM_ID));
+    return statePda;
+};
+export const getDriftSpotMarketPublicKey = (marketIndex) => {
+    const [spotMarketVaultPda] = PublicKey.findProgramAddressSync([
+        Buffer.from("spot_market_vault"),
+        new BN(marketIndex).toArrayLike(Buffer, 'le', 2)
+    ], new PublicKey(DRIFT_PROGRAM_ID));
+    return spotMarketVaultPda;
+};
+export const toRemainingAccount = (pubkey, isWritable, isSigner) => {
+    return { pubkey, isWritable, isSigner };
+};

package/dist/utils/jupiter.d.ts

@@ -0,0 +1,7 @@
+import { PublicKey, Connection, TransactionInstruction } from "@solana/web3.js";
+import { QuoteResponse } from "@jup-ag/api";
+import { AddressLookupTableAccount } from "@solana/web3.js";
+export declare function getJupiterSwapIx(walletPubkey: PublicKey, connection: Connection, quoteResponse: QuoteResponse): Promise<{
+    ix_jupiterSwap: TransactionInstruction;
+    jupiterLookupTables: AddressLookupTableAccount[];
+}>;

package/dist/utils/jupiter.js

@@ -0,0 +1,48 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { AddressLookupTableAccount } from "@solana/web3.js";
+export async function getJupiterSwapIx(walletPubkey, connection, quoteResponse) {
+    const instructions = await (await fetch('https://quote-api.jup.ag/v6/swap-instructions', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            quoteResponse,
+            userPublicKey: walletPubkey.toBase58(),
+            useCompression: true,
+        })
+    })).json();
+    if (instructions.error) {
+        throw new Error("Failed to get swap instructions: " + instructions.error);
+    }
+    const { swapInstruction, addressLookupTableAddresses } = instructions;
+    const getAddressLookupTableAccounts = async (keys) => {
+        const addressLookupTableAccountInfos = await connection.getMultipleAccountsInfo(keys.map((key) => new PublicKey(key)));
+        return addressLookupTableAccountInfos.reduce((acc, accountInfo, index) => {
+            const addressLookupTableAddress = keys[index];
+            if (accountInfo) {
+                const addressLookupTableAccount = new AddressLookupTableAccount({
+                    key: new PublicKey(addressLookupTableAddress),
+                    state: AddressLookupTableAccount.deserialize(accountInfo.data),
+                });
+                acc.push(addressLookupTableAccount);
+            }
+            return acc;
+        }, new Array());
+    };
+    const addressLookupTableAccounts = [];
+    addressLookupTableAccounts.push(...(await getAddressLookupTableAccounts(addressLookupTableAddresses)));
+    const ix_jupiterSwap = new TransactionInstruction({
+        programId: new PublicKey(swapInstruction.programId),
+        keys: swapInstruction.accounts.map((key) => ({
+            pubkey: new PublicKey(key.pubkey),
+            isSigner: key.isSigner,
+            isWritable: key.isWritable,
+        })),
+        data: Buffer.from(swapInstruction.data, "base64"),
+    });
+    return {
+        ix_jupiterSwap,
+        jupiterLookupTables: addressLookupTableAccounts,
+    };
+}

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@quartz-labs/sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "SDK for interacting with the Quartz Protocol",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "typesVersions": {
-    ">=4.7": { "*": ["ts/*"] }
+    ">=4.7": {
+      "*": [
+        "ts/*"
+      ]
+    }
   },
   "scripts": {
     "build": "tsc",
@@ -38,7 +45,9 @@
   "dependencies": {
     "@coral-xyz/anchor": "^0.29.0",
     "@drift-labs/sdk": "^2.103.0-beta.9",
+    "@jup-ag/api": "^6.0.30",
     "@pythnetwork/pyth-solana-receiver": "^0.8.2",
+    "@solana/spl-token": "^0.4.9",
     "@solana/web3.js": "^1.95.8"
   }
 }

package/src/client.ts

@@ -1,117 +0,0 @@
-import { DriftClient, fetchUserAccountsUsingKeys as fetchDriftAccountsUsingKeys } from "@drift-labs/sdk";
-import { QUARTZ_ADDRESS_TABLE, QUARTZ_PROGRAM_ID, SUPPORTED_DRIFT_MARKETS } from "./config/constants";
-import quartzIdl from "./idl/quartz.json";
-import { Quartz } from "./types/quartz.js";
-import { AnchorProvider, Idl, Program, setProvider, Wallet } from "@coral-xyz/anchor";
-import { Connection, AddressLookupTableAccount } from "@solana/web3.js";
-import { PythSolanaReceiver } from "@pythnetwork/pyth-solana-receiver";
-import { PublicKey } from "@solana/web3.js";
-import { QuartzUser } from "./user";
-import { getDriftUser, getVaultPubkey } from "./helpers";
-
-export class QuartzClient {
-    private connection: Connection;
-    private wallet: Wallet;
-    private program: Program<Quartz>;
-    private quartzAddressTable: AddressLookupTableAccount;
-
-    private driftClient: DriftClient;
-    private oracles: Map<string, PublicKey>;
-
-    constructor(
-        connection: Connection,
-        wallet: Wallet,
-        program: Program<Quartz>,
-        quartzAddressTable: AddressLookupTableAccount,
-        driftClient: DriftClient,
-        oracles: Map<string, PublicKey>
-    ) {
-        this.connection = connection;
-        this.wallet = wallet;
-        this.program = program;
-        this.quartzAddressTable = quartzAddressTable;
-        this.driftClient = driftClient;
-        this.oracles = oracles;
-    }
-
-    static async initialize(
-        connection: Connection, 
-        wallet: Wallet
-    ) {
-        const provider = new AnchorProvider(connection, wallet, { commitment: "confirmed" });
-        setProvider(provider);
-        const program = new Program(quartzIdl as Idl, QUARTZ_PROGRAM_ID, provider) as unknown as Program<Quartz>;
-
-        const quartzLookupTable = await connection.getAddressLookupTable(QUARTZ_ADDRESS_TABLE).then((res) => res.value);
-        if (!quartzLookupTable) throw Error("Address Lookup Table account not found");
-
-        const driftClient = new DriftClient({
-            connection,
-            wallet,
-            env: 'mainnet-beta',
-            userStats: false,
-            perpMarketIndexes: [],
-            spotMarketIndexes: SUPPORTED_DRIFT_MARKETS,
-            accountSubscription: {
-                type: 'websocket',
-                commitment: "confirmed"
-            }
-        });
-        await driftClient.subscribe();
-
-        const pythSolanaReceiver = new PythSolanaReceiver({ connection, wallet });
-        const oracles = new Map<string, PublicKey>([
-            ["SOL/USD", pythSolanaReceiver.getPriceFeedAccountAddress(0, 
-                "0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d")],
-            ["USDC/USD", pythSolanaReceiver.getPriceFeedAccountAddress(0, 
-                "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a")]
-        ]);
-
-        return new QuartzClient(
-            connection, 
-            wallet, 
-            program, 
-            quartzLookupTable,
-            driftClient,
-            oracles
-        );
-    }
-
-    public async getAllAccountPubkeys(): Promise<PublicKey[]> {
-        return (
-            await this.program.account.vault.all()
-        ).map((vault) => vault.publicKey);
-    }
-
-    public async getQuartzAccount(pubkey: PublicKey): Promise<QuartzUser> {
-        const vault = getVaultPubkey(pubkey);
-        await this.program.account.vault.fetch(vault); // Check account exists
-        return new QuartzUser(pubkey, this.connection, this.driftClient);
-    }
-
-    public async getMultipleQuartzAccounts(pubkeys: PublicKey[]): Promise<QuartzUser[]> {
-        if (pubkeys.length === 0) return [];
-
-        const vaults = pubkeys.map((pubkey) => getVaultPubkey(pubkey));
-        const accounts = await this.program.account.vault.fetchMultiple(vaults);
-
-        accounts.forEach((account, index) => {
-            if (account === null) throw Error(`Account not found for pubkey: ${pubkeys[index].toBase58()}`)
-        });
-
-        const driftUsers = await fetchDriftAccountsUsingKeys(
-            this.connection,
-            this.driftClient.program,
-            vaults.map((vault) => getDriftUser(vault))
-        )
-
-        const undefinedIndex = driftUsers.findIndex(user => !user);
-        if (undefinedIndex !== -1) {
-            throw new Error(`[${this.wallet?.publicKey}] Failed to fetch drift user for vault ${vaults[undefinedIndex].toBase58()}`);
-        }
-
-        return driftUsers.map((driftUser, index) => {
-            return new QuartzUser(pubkeys[index], this.connection, this.driftClient, driftUser)
-        });
-    }
-}

package/src/helpers.ts

@@ -1,33 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import { QUARTZ_PROGRAM_ID } from "./config/constants";
-import { BN } from "@coral-xyz/anchor";
-import { DRIFT_PROGRAM_ID } from "@drift-labs/sdk";
-
-export const getVaultPubkey = (owner: PublicKey) => {
-    const [vaultPda] = PublicKey.findProgramAddressSync(
-        [Buffer.from("vault"), owner.toBuffer()],
-        QUARTZ_PROGRAM_ID
-    )
-    return vaultPda;
-}
-
-export const getVaultSplPubkey = (owner: PublicKey, mint: PublicKey) => {
-    const vaultPda = getVaultPubkey(owner);
-    const [vaultSplPda] = PublicKey.findProgramAddressSync(
-        [vaultPda.toBuffer(), mint.toBuffer()],
-        QUARTZ_PROGRAM_ID
-    );
-    return vaultSplPda;
-}
-
-export const getDriftUser = (vaultPda: PublicKey) => {
-    const [userPda] = PublicKey.findProgramAddressSync(
-        [
-			Buffer.from("user"),
-			vaultPda.toBuffer(),
-			new BN(0).toArrayLike(Buffer, 'le', 2),
-		],
-		new PublicKey(DRIFT_PROGRAM_ID)
-    );
-    return userPda;
-}