@quartz-labs/sdk 0.0.1 → 0.0.2

package/README.md

@@ -14,4 +14,4 @@ Docs: [docs.quartzpay.io](https://docs.quartzpay.io/)
 
 X: [@quartzpay](https://x.com/quartzpay)
 
-Contact: [diego@quartzpay.io](mailto:diego@quartzpay.io)
+Contact: [iarla@quartzpay.io](mailto:diego@quartzpay.io)

package/build/client.d.ts

@@ -0,0 +1,19 @@
+import { DriftClient } from "@drift-labs/sdk";
+import { Quartz } from "./types/quartz.js";
+import { Program, Wallet } from "@coral-xyz/anchor";
+import { Connection, AddressLookupTableAccount } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
+import { QuartzUser } from "./user";
+export declare class QuartzClient {
+    private connection;
+    private wallet;
+    private program;
+    private quartzAddressTable;
+    private driftClient;
+    private oracles;
+    constructor(connection: Connection, wallet: Wallet, program: Program<Quartz>, quartzAddressTable: AddressLookupTableAccount, driftClient: DriftClient, oracles: Map<string, PublicKey>);
+    static initialize(connection: Connection, wallet: Wallet): Promise<QuartzClient>;
+    getAllQuartzAccountPubkeys(): Promise<PublicKey[]>;
+    getQuartzAccount(vault: PublicKey): Promise<QuartzUser>;
+    getMultipleQuartzAccounts(vaults: PublicKey[]): Promise<(QuartzUser | null)[]>;
+}

package/build/client.js

@@ -0,0 +1,60 @@
+import { fetchUserAccountsUsingKeys as fetchDriftAccountsUsingKeys } from "@drift-labs/sdk";
+import { QUARTZ_ADDRESS_TABLE, QUARTZ_PROGRAM_ID } from "./config/constants";
+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 { 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.driftClient = driftClient;
+        this.oracles = oracles;
+    }
+    static async initialize(connection, wallet) {
+        const provider = new AnchorProvider(connection, wallet, { commitment: "confirmed" });
+        setProvider(provider);
+        const program = new Program(quartzIdl, QUARTZ_PROGRAM_ID, provider);
+        const quartzLookupTable = await connection.getAddressLookupTable(QUARTZ_ADDRESS_TABLE).then((res) => res.value);
+        if (!quartzLookupTable)
+            throw Error("Address Lookup Table account not found");
+        const driftClient = await DriftClientService.getDriftClient(connection);
+        const pythSolanaReceiver = new PythSolanaReceiver({ connection, wallet });
+        const oracles = new Map([
+            ["SOL/USD", pythSolanaReceiver.getPriceFeedAccountAddress(0, "0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d")],
+            ["USDC/USD", pythSolanaReceiver.getPriceFeedAccountAddress(0, "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a")]
+        ]);
+        return new QuartzClient(connection, wallet, program, quartzLookupTable, driftClient, oracles);
+    }
+    async getAllQuartzAccountPubkeys() {
+        return (await this.program.account.vault.all()).map((vault) => vault.publicKey);
+    }
+    async getQuartzAccount(vault) {
+        await this.program.account.vault.fetch(vault); // Check account exists
+        return new QuartzUser(vault, this.connection, this.driftClient);
+    }
+    async getMultipleQuartzAccounts(vaults) {
+        if (vaults.length === 0)
+            return [];
+        const accounts = await this.program.account.vault.fetchMultiple(vaults);
+        accounts.forEach((account, index) => {
+            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)));
+        // TODO: Uncomment once Drift accounts are guaranteed
+        // 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) => {
+            if (driftUser === undefined)
+                return null;
+            return new QuartzUser(vaults[index], this.connection, this.driftClient, driftUser);
+        });
+    }
+}

package/build/config/constants.d.ts

@@ -0,0 +1,7 @@
+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 DRIFT_MARKET_INDEX_USDC = 0;
+export declare const DRIFT_MARKET_INDEX_SOL = 1;
+export declare const SUPPORTED_DRIFT_MARKETS: number[];

package/build/config/constants.js

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,12 @@
+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/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 getVaultPubkey = (user) => {
+    const [vaultPda] = PublicKey.findProgramAddressSync([Buffer.from("vault"), user.toBuffer()], QUARTZ_PROGRAM_ID);
+    return vaultPda;
+};
+export const getVaultSplPubkey = (user, mint) => {
+    const vaultPda = getVaultPubkey(user);
+    const [vaultSplPda] = PublicKey.findProgramAddressSync([vaultPda.toBuffer(), mint.toBuffer()], QUARTZ_PROGRAM_ID);
+    return vaultSplPda;
+};
+export const getDriftUser = (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 getDriftUserStats = (vaultPda) => {
+    const [userStatsPda] = PublicKey.findProgramAddressSync([Buffer.from("user_stats"), vaultPda.toBuffer()], new PublicKey(DRIFT_PROGRAM_ID));
+    return userStatsPda;
+};
+export const getDriftState = () => {
+    const [statePda] = PublicKey.findProgramAddressSync([Buffer.from("drift_state")], new PublicKey(DRIFT_PROGRAM_ID));
+    return statePda;
+};
+export const getDriftSpotMarketVault = (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 };
+};