@drift-labs/sdk 0.2.0-master.6 → 0.2.0-master.9

package/lib/clearingHouse.js

@@ -615,7 +615,7 @@ class ClearingHouse {
                 bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
                     pubkey: bankAccount.pubkey,
                     isSigner: false,
-                    isWritable: false,
+                    isWritable: true,
                 });
                 if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
                     oracleAccountMap.set(bankAccount.oracle.toString(), {
@@ -674,44 +674,57 @@ class ClearingHouse {
         const fillerPublicKey = await this.getUserAccountPublicKey();
         const marketIndex = order.marketIndex;
         const marketAccount = this.getMarketAccount(marketIndex);
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
-            },
-        ];
-        const marketAccountInfos = [
-            {
-                pubkey: marketAccount.pubkey,
-                isWritable: true,
-                isSigner: false,
-            },
-        ];
-        const oracleAccountInfos = [
-            {
-                pubkey: marketAccount.amm.oracle,
-                isWritable: false,
-                isSigner: false,
-            },
-        ];
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        const marketAccountMap = new Map();
+        marketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: marketAccount.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+            pubkey: marketAccount.amm.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        for (const bankBalance of userAccount.bankBalances) {
+            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
+                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+                    pubkey: bankAccount.pubkey,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                        pubkey: bankAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
         for (const position of userAccount.positions) {
             if (!(0, position_1.positionIsAvailable)(position) &&
                 !position.marketIndex.eq(order.marketIndex)) {
                 const market = this.getMarketAccount(position.marketIndex);
-                marketAccountInfos.push({
+                marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: false,
+                    isWritable: true,
                     isSigner: false,
                 });
-                oracleAccountInfos.push({
+                oracleAccountMap.set(market.amm.oracle.toString(), {
                     pubkey: market.amm.oracle,
                     isWritable: false,
                     isSigner: false,
                 });
             }
         }
-        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
         const orderId = order.orderId;
         return await this.program.instruction.triggerOrder(orderId, {
             accounts: {

package/lib/constants/banks.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Banks = exports.MainnetBanks = exports.DevnetBanks = void 0;
 const __1 = require("../");
 const web3_js_1 = require("@solana/web3.js");
+const token_instructions_1 = require("@project-serum/serum/lib/token-instructions");
 exports.DevnetBanks = [
     {
         symbol: 'USDC',
@@ -12,8 +13,15 @@ exports.DevnetBanks = [
         mint: new web3_js_1.PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
     },
     {
-        symbol: 'BTC',
+        symbol: 'SOL',
         bankIndex: new __1.BN(1),
+        oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: token_instructions_1.WRAPPED_SOL_MINT,
+    },
+    {
+        symbol: 'BTC',
+        bankIndex: new __1.BN(2),
         oracle: new web3_js_1.PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
         oracleSource: __1.OracleSource.PYTH,
         mint: new web3_js_1.PublicKey('Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr'),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.6",
+	"version": "0.2.0-master.9",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.js

@@ -0,0 +1,197 @@
+"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.BulkAccountLoader = void 0;
+const uuid_1 = require("uuid");
+const promiseTimeout_1 = require("../util/promiseTimeout");
+const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
+const oneMinute = 60 * 1000;
+class BulkAccountLoader {
+    constructor(connection, commitment, pollingFrequency) {
+        this.accountsToLoad = new Map();
+        this.bufferAndSlotMap = new Map();
+        this.errorCallbacks = new Map();
+        this.lastTimeLoadingPromiseCleared = Date.now();
+        this.mostRecentSlot = 0;
+        this.connection = connection;
+        this.commitment = commitment;
+        this.pollingFrequency = pollingFrequency;
+    }
+    addAccount(publicKey, callback) {
+        const existingSize = this.accountsToLoad.size;
+        const callbackId = uuid_1.v4();
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.set(callbackId, callback);
+        }
+        else {
+            const callbacks = new Map();
+            callbacks.set(callbackId, callback);
+            const newAccountToLoad = {
+                publicKey,
+                callbacks,
+            };
+            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
+        }
+        if (existingSize === 0) {
+            this.startPolling();
+        }
+        // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
+        this.loadPromise = undefined;
+        return callbackId;
+    }
+    removeAccount(publicKey, callbackId) {
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.delete(callbackId);
+            if (existingAccountToLoad.callbacks.size === 0) {
+                this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
+            }
+        }
+        if (this.accountsToLoad.size === 0) {
+            this.stopPolling();
+        }
+    }
+    addErrorCallbacks(callback) {
+        const callbackId = uuid_1.v4();
+        this.errorCallbacks.set(callbackId, callback);
+        return callbackId;
+    }
+    removeErrorCallbacks(callbackId) {
+        this.errorCallbacks.delete(callbackId);
+    }
+    chunks(array, size) {
+        return new Array(Math.ceil(array.length / size))
+            .fill(null)
+            .map((_, index) => index * size)
+            .map((begin) => array.slice(begin, begin + size));
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadPromise) {
+                const now = Date.now();
+                if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+                    this.loadPromise = undefined;
+                }
+                else {
+                    return this.loadPromise;
+                }
+            }
+            this.loadPromise = new Promise((resolver) => {
+                this.loadPromiseResolver = resolver;
+            });
+            this.lastTimeLoadingPromiseCleared = Date.now();
+            try {
+                const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
+                yield Promise.all(chunks.map((chunk) => {
+                    return this.loadChunk(chunk);
+                }));
+            }
+            catch (e) {
+                console.error(`Error in bulkAccountLoader.load()`);
+                console.error(e);
+                for (const [_, callback] of this.errorCallbacks) {
+                    callback(e);
+                }
+            }
+            finally {
+                this.loadPromiseResolver();
+                this.loadPromise = undefined;
+            }
+        });
+    }
+    loadChunk(accountsToLoad) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (accountsToLoad.length === 0) {
+                return;
+            }
+            const args = [
+                accountsToLoad.map((accountToLoad) => {
+                    return accountToLoad.publicKey.toBase58();
+                }),
+                { commitment: this.commitment },
+            ];
+            const rpcResponse = yield promiseTimeout_1.promiseTimeout(
+            // @ts-ignore
+            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
+            );
+            if (rpcResponse === null) {
+                this.log('request to rpc timed out');
+                return;
+            }
+            const newSlot = rpcResponse.result.context.slot;
+            if (newSlot > this.mostRecentSlot) {
+                this.mostRecentSlot = newSlot;
+            }
+            for (const i in accountsToLoad) {
+                const accountToLoad = accountsToLoad[i];
+                const key = accountToLoad.publicKey.toString();
+                const oldRPCResponse = this.bufferAndSlotMap.get(key);
+                let newBuffer = undefined;
+                if (rpcResponse.result.value[i]) {
+                    const raw = rpcResponse.result.value[i].data[0];
+                    const dataType = rpcResponse.result.value[i].data[1];
+                    newBuffer = Buffer.from(raw, dataType);
+                }
+                if (!oldRPCResponse) {
+                    this.bufferAndSlotMap.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                    continue;
+                }
+                if (newSlot <= oldRPCResponse.slot) {
+                    continue;
+                }
+                const oldBuffer = oldRPCResponse.buffer;
+                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                    this.bufferAndSlotMap.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                }
+            }
+        });
+    }
+    handleAccountCallbacks(accountToLoad, buffer, slot) {
+        for (const [_, callback] of accountToLoad.callbacks) {
+            callback(buffer, slot);
+        }
+    }
+    getBufferAndSlot(publicKey) {
+        return this.bufferAndSlotMap.get(publicKey.toString());
+    }
+    startPolling() {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+    }
+    stopPolling() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    log(msg) {
+        console.log(msg);
+    }
+    updatePollingFrequency(pollingFrequency) {
+        this.stopPolling();
+        this.pollingFrequency = pollingFrequency;
+        if (this.accountsToLoad.size > 0) {
+            this.startPolling();
+        }
+    }
+}
+exports.BulkAccountLoader = BulkAccountLoader;

package/src/accounts/bulkUserSubscription.js

@@ -0,0 +1,33 @@
+"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.bulkPollingUserSubscribe = void 0;
+/**
+ * @param users
+ * @param accountLoader
+ */
+function bulkPollingUserSubscribe(users, accountLoader) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (users.length === 0) {
+            yield accountLoader.load();
+            return;
+        }
+        yield Promise.all(users.map((user) => {
+            // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
+            return user.accountSubscriber.addToAccountLoader();
+        }));
+        yield accountLoader.load();
+        yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
+            return user.subscribe();
+        })));
+    });
+}
+exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;

package/src/accounts/fetch.js

@@ -0,0 +1,29 @@
+"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.fetchUserAccounts = void 0;
+const pda_1 = require("../addresses/pda");
+function fetchUserAccounts(connection, program, authority, limit = 8) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const userAccountPublicKeys = new Array();
+        for (let i = 0; i < limit; i++) {
+            userAccountPublicKeys.push(yield pda_1.getUserAccountPublicKey(program.programId, authority, i));
+        }
+        const accountInfos = yield connection.getMultipleAccountsInfo(userAccountPublicKeys, 'confirmed');
+        return accountInfos.map((accountInfo) => {
+            if (!accountInfo) {
+                return undefined;
+            }
+            return program.account.user.coder.accounts.decode('User', accountInfo.data);
+        });
+    });
+}
+exports.fetchUserAccounts = fetchUserAccounts;