@quartz-labs/sdk 0.0.2 → 0.0.3

package/{build → dist}/client.d.ts

@@ -8,7 +8,7 @@ export declare class QuartzClient {
     private connection;
     private wallet;
     private program;
-    private quartzAddressTable;
+    private quartzLookupTable;
     private driftClient;
     private oracles;
     constructor(connection: Connection, wallet: Wallet, program: Program<Quartz>, quartzAddressTable: AddressLookupTableAccount, driftClient: DriftClient, oracles: Map<string, PublicKey>);

package/{build → dist}/client.js

@@ -4,14 +4,14 @@ import quartzIdl from "./idl/quartz.json";
 import { AnchorProvider, Program, setProvider } from "@coral-xyz/anchor";
 import { PythSolanaReceiver } from "@pythnetwork/pyth-solana-receiver";
 import { QuartzUser } from "./user";
-import { getDriftUser } from "./helpers";
+import { getDriftUserPublicKey } from "./utils/helpers";
 import { DriftClientService } from "./services/driftClientService";
 export class QuartzClient {
     constructor(connection, wallet, program, quartzAddressTable, driftClient, oracles) {
         this.connection = connection;
         this.wallet = wallet;
         this.program = program;
-        this.quartzAddressTable = quartzAddressTable;
+        this.quartzLookupTable = quartzAddressTable;
         this.driftClient = driftClient;
         this.oracles = oracles;
     }
@@ -35,7 +35,7 @@ export class QuartzClient {
     }
     async getQuartzAccount(vault) {
         await this.program.account.vault.fetch(vault); // Check account exists
-        return new QuartzUser(vault, this.connection, this.driftClient);
+        return new QuartzUser(vault, this.connection, this.program, this.quartzLookupTable, this.oracles, this.driftClient);
     }
     async getMultipleQuartzAccounts(vaults) {
         if (vaults.length === 0)
@@ -45,7 +45,7 @@ export class QuartzClient {
             if (account === null)
                 throw Error(`Account not found for pubkey: ${vaults[index].toBase58()}`);
         });
-        const driftUsers = await fetchDriftAccountsUsingKeys(this.connection, this.driftClient.program, vaults.map((vault) => getDriftUser(vault)));
+        const driftUsers = await fetchDriftAccountsUsingKeys(this.connection, this.driftClient.program, vaults.map((vault) => getDriftUserPublicKey(vault)));
         // TODO: Uncomment once Drift accounts are guaranteed
         // const undefinedIndex = driftUsers.findIndex(user => !user);
         // if (undefinedIndex !== -1) {
@@ -54,7 +54,7 @@ export class QuartzClient {
         return driftUsers.map((driftUser, index) => {
             if (driftUser === undefined)
                 return null;
-            return new QuartzUser(vaults[index], this.connection, this.driftClient, driftUser);
+            return new QuartzUser(vaults[index], this.connection, this.program, this.quartzLookupTable, this.oracles, this.driftClient);
         });
     }
 }

package/{build → dist}/config/constants.d.ts

@@ -2,6 +2,8 @@ import { PublicKey } from "@solana/web3.js";
 export declare const QUARTZ_PROGRAM_ID: PublicKey;
 export declare const QUARTZ_ADDRESS_TABLE: PublicKey;
 export declare const QUARTZ_HEALTH_BUFFER = 0.1;
+export declare const USDC_MINT: PublicKey;
+export declare const WSOL_MINT: PublicKey;
 export declare const DRIFT_MARKET_INDEX_USDC = 0;
 export declare const DRIFT_MARKET_INDEX_SOL = 1;
 export declare const SUPPORTED_DRIFT_MARKETS: number[];

package/{src/config/constants.ts → dist/config/constants.js}

@@ -1,13 +1,9 @@
 import { PublicKey } from "@solana/web3.js";
-
 export const QUARTZ_PROGRAM_ID = new PublicKey("6JjHXLheGSNvvexgzMthEcgjkcirDrGduc3HAKB2P1v2");
 export const QUARTZ_ADDRESS_TABLE = new PublicKey("96BmeKKVGX3LKYSKo3FCEom1YpNY11kCnGscKq6ouxLx");
-
 export const QUARTZ_HEALTH_BUFFER = 0.1;
-
 export const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
 export const WSOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
-
 export const DRIFT_MARKET_INDEX_USDC = 0;
 export const DRIFT_MARKET_INDEX_SOL = 1;
-export const SUPPORTED_DRIFT_MARKETS = [DRIFT_MARKET_INDEX_USDC, DRIFT_MARKET_INDEX_SOL];
+export const SUPPORTED_DRIFT_MARKETS = [DRIFT_MARKET_INDEX_USDC, DRIFT_MARKET_INDEX_SOL];

package/{src/index.ts → dist/index.d.ts}

@@ -1,5 +1,4 @@
 import { QuartzClient } from "./client";
-
 export * from "./config/constants";
 export * from "./utils/helpers";
-export { QuartzClient };
+export { QuartzClient };

package/{build → dist}/index.js

@@ -1,4 +1,4 @@
 import { QuartzClient } from "./client";
 export * from "./config/constants";
-export * from "./helpers";
+export * from "./utils/helpers";
 export { QuartzClient };

package/{build → dist}/model/driftUser.d.ts

@@ -6,8 +6,11 @@ export declare class DriftUser {
     private connection;
     private driftClient;
     private userAccount;
+    pubkey: PublicKey;
+    statsPubkey: PublicKey;
     constructor(authority: PublicKey, connection: Connection, driftClient: DriftClient, userAccount?: UserAccount);
     initialize(): Promise<void>;
+    getDriftUserAccount(): UserAccount;
     getHealth(): number;
     getTokenAmount(marketIndex: number): BN;
     getWithdrawalLimit(marketIndex: number, reduceOnly?: boolean): BN;

package/{build → dist}/model/driftUser.js

@@ -1,11 +1,13 @@
 import { AMM_RESERVE_PRECISION, AMM_RESERVE_PRECISION_EXP, BN, calculateAssetWeight, calculateLiabilityWeight, calculateLiveOracleTwap, calculateMarketMarginRatio, calculateMarketOpenBidAsk, calculatePerpLiabilityValue, calculatePositionPNL, calculateUnrealizedAssetWeight, calculateUnsettledFundingPnl, calculateWithdrawLimit, calculateWorstCasePerpLiabilityValue, fetchUserAccountsUsingKeys, FIVE_MINUTE, getSignedTokenAmount, getStrictTokenValue, getTokenAmount, getWorstCaseTokenAmounts, isSpotPositionAvailable, isVariant, MARGIN_PRECISION, ONE, OPEN_ORDER_MARGIN_REQUIREMENT, PRICE_PRECISION, QUOTE_PRECISION, QUOTE_SPOT_MARKET_INDEX, SPOT_MARKET_WEIGHT_PRECISION, SpotBalanceType, StrictOraclePrice, UserStatus, ZERO, TEN, divCeil } from "@drift-labs/sdk";
-import { getDriftUser } from "../helpers.js";
+import { getDriftUserPublicKey, getDriftUserStatsPublicKey } from "../utils/helpers.js";
 export class DriftUser {
     constructor(authority, connection, driftClient, userAccount) {
         this.isInitialized = false;
         this.authority = authority;
         this.connection = connection;
         this.driftClient = driftClient;
+        this.pubkey = getDriftUserPublicKey(this.authority);
+        this.statsPubkey = getDriftUserStatsPublicKey(this.authority);
         if (userAccount) {
             this.userAccount = userAccount;
             this.isInitialized = true;
@@ -14,12 +16,17 @@ export class DriftUser {
     async initialize() {
         if (this.isInitialized)
             return;
-        const [userAccount] = await fetchUserAccountsUsingKeys(this.connection, this.driftClient.program, [getDriftUser(this.authority)]);
+        const [userAccount] = await fetchUserAccountsUsingKeys(this.connection, this.driftClient.program, [this.pubkey]);
         if (!userAccount)
             throw new Error("Drift user not found");
         this.userAccount = userAccount;
         this.isInitialized = true;
     }
+    getDriftUserAccount() {
+        if (!this.isInitialized)
+            throw new Error("DriftUser not initialized");
+        return this.userAccount;
+    }
     getHealth() {
         if (!this.isInitialized)
             throw new Error("DriftUser not initialized");

package/dist/user.d.ts

@@ -0,0 +1,25 @@
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { DriftClient, QuoteResponse, UserAccount } from "@drift-labs/sdk";
+import { Connection } from "@solana/web3.js";
+import { Quartz } from "./types/quartz";
+import { Program } from "@coral-xyz/anchor";
+export declare class QuartzUser {
+    private pubkey;
+    private vaultPubkey;
+    private connection;
+    private program;
+    private quartzLookupTable;
+    private oracles;
+    private driftClient;
+    private driftUser;
+    constructor(pubkey: PublicKey, connection: Connection, program: Program<Quartz>, quartzLookupTable: AddressLookupTableAccount, oracles: Map<string, PublicKey>, driftClient: DriftClient, driftUserAccount?: UserAccount);
+    private convertToQuartzHealth;
+    getHealth(): number;
+    getRepayAmountForTargetHealth(targetHealth: number, repayCollateralWeight: number): number;
+    getTotalWeightedCollateral(): number;
+    getMaintenanceMarginRequirement(): number;
+    makeCollateralRepayIxs(caller: PublicKey, callerDepositSpl: PublicKey, callerWithdrawSpl: PublicKey, callerStartingDepositBalance: number, jupiterExactOutRouteQuote: QuoteResponse): Promise<{
+        ixs: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
+}

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/{build → dist/utils}/helpers.js

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

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,9 +1,12 @@
 {
   "name": "@quartz-labs/sdk",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "SDK for interacting with the Quartz Protocol",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "typesVersions": {
     ">=4.7": {
       "*": [

package/build/config/constants.js

@@ -1,7 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-export const QUARTZ_PROGRAM_ID = new PublicKey("6JjHXLheGSNvvexgzMthEcgjkcirDrGduc3HAKB2P1v2");
-export const QUARTZ_ADDRESS_TABLE = new PublicKey("96BmeKKVGX3LKYSKo3FCEom1YpNY11kCnGscKq6ouxLx");
-export const QUARTZ_HEALTH_BUFFER = 0.1;
-export const DRIFT_MARKET_INDEX_USDC = 0;
-export const DRIFT_MARKET_INDEX_SOL = 1;
-export const SUPPORTED_DRIFT_MARKETS = [DRIFT_MARKET_INDEX_USDC, DRIFT_MARKET_INDEX_SOL];

package/build/helpers.d.ts

@@ -1,12 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-export declare const getVaultPubkey: (user: PublicKey) => PublicKey;
-export declare const getVaultSplPubkey: (user: PublicKey, mint: PublicKey) => PublicKey;
-export declare const getDriftUser: (vaultPda: PublicKey) => PublicKey;
-export declare const getDriftUserStats: (vaultPda: PublicKey) => PublicKey;
-export declare const getDriftState: () => PublicKey;
-export declare const getDriftSpotMarketVault: (marketIndex: number) => PublicKey;
-export declare const toRemainingAccount: (pubkey: PublicKey, isWritable: boolean, isSigner: boolean) => {
-    pubkey: PublicKey;
-    isWritable: boolean;
-    isSigner: boolean;
-};

package/build/index.d.ts

@@ -1,4 +0,0 @@
-import { QuartzClient } from "./client";
-export * from "./config/constants";
-export * from "./helpers";
-export { QuartzClient };

package/build/user.d.ts

@@ -1,16 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import { DriftClient, UserAccount } from "@drift-labs/sdk";
-import { Connection } from "@solana/web3.js";
-export declare class QuartzUser {
-    private pubkey;
-    private vaultPubkey;
-    private connection;
-    private driftClient;
-    private driftUser;
-    constructor(pubkey: PublicKey, connection: Connection, driftClient: DriftClient, driftUserAccount?: UserAccount);
-    private convertToQuartzHealth;
-    getHealth(): number;
-    getRepayAmountForTargetHealth(targetHealth: number, repayCollateralWeight: number): number;
-    getTotalWeightedCollateral(): number;
-    getMaintenanceMarginRequirement(): number;
-}

package/build/user.js

@@ -1,47 +0,0 @@
-import { DriftUser } from "./model/driftUser";
-import { getVaultPubkey } from "./helpers";
-import { QUARTZ_HEALTH_BUFFER } from "./config/constants";
-export class QuartzUser {
-    constructor(pubkey, connection, driftClient, driftUserAccount) {
-        this.pubkey = pubkey;
-        this.vaultPubkey = getVaultPubkey(pubkey);
-        this.connection = connection;
-        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();
-    }
-}

package/jest.config.js

@@ -1,4 +0,0 @@
-module.exports = {
-    preset: "ts-jest",
-    testEnvironment: "node",
-};