@drift-labs/sdk 0.2.0-master.15 → 0.2.0-master.18

package/src/math/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootBN = void 0;
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
+    // Assuming the sqrt of n as n only
+    let x = n;
+    // The closed guess will be stored in the root
+    let root;
+    // To count the number of iterations
+    let count = 0;
+    const TWO = new __1.BN(2);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    while (count < Number.MAX_SAFE_INTEGER) {
+        count++;
+        // Calculate more closed x
+        root = x.add(n.div(x)).div(TWO);
+        // Check for closeness
+        if (x.sub(root).abs().lte(closeness))
+            break;
+        // Update root
+        x = root;
+    }
+    return root;
+};
+exports.squareRootBN = squareRootBN;

package/src/math/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;;AAAA,2BAAyB;AAElB,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,EAAE,EAAE;IACxD,mCAAmC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEV,8CAA8C;IAC9C,IAAI,IAAI,CAAC;IAET,oCAAoC;IACpC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,CAAC;IAEtB,6DAA6D;IAC7D,OAAO,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE;QACvC,KAAK,EAAE,CAAC;QAER,0BAA0B;QAC1B,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEhC,sBAAsB;QACtB,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,MAAM;QAE5C,cAAc;QACd,CAAC,GAAG,IAAI,CAAC;KACT;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AA1BW,QAAA,YAAY,gBA0BvB"}

package/src/oracles/oracleClientCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleClientCache = void 0;
+const oracleClient_1 = require("../factory/oracleClient");
+class OracleClientCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(oracleSource, connection) {
+        const key = Object.keys(oracleSource)[0];
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const client = oracleClient_1.getOracleClient(oracleSource, connection);
+        this.cache.set(key, client);
+        return client;
+    }
+}
+exports.OracleClientCache = OracleClientCache;

package/src/oracles/pythClient.js

@@ -0,0 +1,46 @@
+"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.convertPythPrice = exports.PythClient = void 0;
+const client_1 = require("@pythnetwork/client");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+class PythClient {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    getOraclePriceData(pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountInfo = yield this.connection.getAccountInfo(pricePublicKey);
+            return this.getOraclePriceDataFromBuffer(accountInfo.data);
+        });
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const priceData = client_1.parsePriceData(buffer);
+        return {
+            price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
+            slot: new anchor_1.BN(priceData.lastSlot.toString()),
+            confidence: convertPythPrice(priceData.confidence, priceData.exponent),
+            twap: convertPythPrice(priceData.twap.value, priceData.exponent),
+            twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
+            hasSufficientNumberOfDataPoints: true,
+        };
+    }
+}
+exports.PythClient = PythClient;
+function convertPythPrice(price, exponent) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs());
+    return new anchor_1.BN(price * Math.pow(10, exponent))
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(pythPrecision);
+}
+exports.convertPythPrice = convertPythPrice;

package/src/oracles/quoteAssetOracleClient.js

@@ -0,0 +1,32 @@
+"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.QuoteAssetOracleClient = exports.QUOTE_ORACLE_PRICE_DATA = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+exports.QUOTE_ORACLE_PRICE_DATA = {
+    price: numericConstants_1.MARK_PRICE_PRECISION,
+    slot: new anchor_1.BN(0),
+    confidence: new anchor_1.BN(1),
+    hasSufficientNumberOfDataPoints: true,
+};
+class QuoteAssetOracleClient {
+    constructor() { }
+    getOraclePriceData(_pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(exports.QUOTE_ORACLE_PRICE_DATA);
+        });
+    }
+    getOraclePriceDataFromBuffer(_buffer) {
+        return exports.QUOTE_ORACLE_PRICE_DATA;
+    }
+}
+exports.QuoteAssetOracleClient = QuoteAssetOracleClient;

package/src/oracles/switchboardClient.js

@@ -0,0 +1,69 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchboardClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const wallet_1 = require("../wallet");
+const switchboard_v2_json_1 = __importDefault(require("../idl/switchboard_v2.json"));
+let program;
+class SwitchboardClient {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    getOraclePriceData(pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountInfo = yield this.connection.getAccountInfo(pricePublicKey);
+            return this.getOraclePriceDataFromBuffer(accountInfo.data);
+        });
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const program = this.getProgram();
+        const aggregatorAccountData = program.account.aggregatorAccountData.coder.accounts.decode('AggregatorAccountData', buffer);
+        const price = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.result);
+        const confidence = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound
+            .stdDeviation);
+        const hasSufficientNumberOfDataPoints = aggregatorAccountData.latestConfirmedRound.numSuccess >=
+            aggregatorAccountData.minOracleResults;
+        const slot = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
+        return {
+            price,
+            slot,
+            confidence,
+            hasSufficientNumberOfDataPoints,
+        };
+    }
+    getProgram() {
+        if (program) {
+            return program;
+        }
+        program = getSwitchboardProgram(this.connection);
+        return program;
+    }
+}
+exports.SwitchboardClient = SwitchboardClient;
+function getSwitchboardProgram(connection) {
+    const DEFAULT_KEYPAIR = web3_js_1.Keypair.fromSeed(new Uint8Array(32).fill(1));
+    const programId = web3_js_1.PublicKey.default;
+    const wallet = new wallet_1.Wallet(DEFAULT_KEYPAIR);
+    const provider = new anchor_1.AnchorProvider(connection, wallet, {});
+    return new anchor_1.Program(switchboard_v2_json_1.default, programId, provider);
+}
+function convertSwitchboardDecimal(switchboardDecimal) {
+    const switchboardPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(switchboardDecimal.scale));
+    return switchboardDecimal.mantissa
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(switchboardPrecision);
+}

package/src/oracles/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/orderParams.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
+const types_1 = require("./types");
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
+}
+exports.getLimitOrderParams = getLimitOrderParams;
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
+}
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
+}
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
+}
+exports.getMarketOrderParams = getMarketOrderParams;

package/src/slot/SlotSubscriber.js

@@ -0,0 +1,39 @@
+"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.SlotSubscriber = void 0;
+const events_1 = require("events");
+class SlotSubscriber {
+    constructor(connection, _config) {
+        this.connection = connection;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentSlot = yield this.connection.getSlot('confirmed');
+            this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+                this.currentSlot = slotInfo.slot;
+                this.eventEmitter.emit('newSlot', slotInfo.slot);
+            });
+        });
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.subscriptionId) {
+                yield this.connection.removeSlotChangeListener(this.subscriptionId);
+            }
+        });
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;

package/src/tokenFaucet.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenFaucet = void 0;
+const anchor = __importStar(require("@project-serum/anchor"));
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
+class TokenFaucet {
+    constructor(connection, wallet, programId, mint, opts) {
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
+        const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
+    }
+    getFaucetConfigPublicKeyAndNonce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+                this.mint.toBuffer(),
+            ], this.program.programId);
+        });
+    }
+    getMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+                this.mint.toBuffer(),
+            ], this.program.programId))[0];
+        });
+    }
+    getFaucetConfigPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getFaucetConfigPublicKeyAndNonce())[0];
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [faucetConfigPublicKey] = yield this.getFaucetConfigPublicKeyAndNonce();
+            return yield this.program.rpc.initialize({
+                accounts: {
+                    faucetConfig: faucetConfigPublicKey,
+                    admin: this.wallet.publicKey,
+                    mintAccount: this.mint,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    fetchState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.account.faucetConfig.fetch(yield this.getFaucetConfigPublicKey());
+        });
+    }
+    mintToUserIx(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.instruction.mintToUser(amount, {
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    userTokenAccount,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    mintToUser(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mintIx = yield this.mintToUserIx(userTokenAccount, amount);
+            const tx = new web3_js_1.Transaction().add(mintIx);
+            const txSig = yield this.program.provider.sendAndConfirm(tx, [], this.opts);
+            return txSig;
+        });
+    }
+    transferMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.transferMintAuthority({
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    admin: this.wallet.publicKey,
+                },
+            });
+        });
+    }
+    createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = new web3_js_1.Transaction();
+            const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = yield this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+            let associatedTokenAccountExists = false;
+            try {
+                const assosciatedTokenAccount = yield this.connection.getAccountInfo(associatedTokenPublicKey);
+                associatedTokenAccountExists = !!assosciatedTokenAccount;
+            }
+            catch (e) {
+                // token account doesn't exist
+                associatedTokenAccountExists = false;
+            }
+            const skipAccountCreation = associatedTokenAccountExists;
+            if (!skipAccountCreation)
+                tx.add(createAssociatedAccountIx);
+            tx.add(mintToTx);
+            const txSig = yield this.program.provider.sendAndConfirm(tx, [], this.opts);
+            return [associatedTokenPublicKey, txSig];
+        });
+    }
+    createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            const associateTokenPublicKey = yield this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
+            const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, associateTokenPublicKey, userPublicKey, this.wallet.publicKey);
+            const mintToIx = yield this.mintToUserIx(associateTokenPublicKey, amount);
+            return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+        });
+    }
+    getAssosciatedMockUSDMintAddress(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, props.userPubKey);
+        });
+    }
+    getTokenAccountInfo(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assosciatedKey = yield this.getAssosciatedMockUSDMintAddress(props);
+            const state = yield this.fetchState();
+            const token = new spl_token_1.Token(this.connection, state.mint, spl_token_1.TOKEN_PROGRAM_ID, 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this.provider.payer);
+            return yield token.getAccountInfo(assosciatedKey);
+        });
+    }
+    subscribeToTokenAccount(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenAccountKey = yield this.getAssosciatedMockUSDMintAddress(props);
+                props.callback(yield this.getTokenAccountInfo(props));
+                // Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
+                this.connection.onAccountChange(tokenAccountKey, (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => __awaiter(this, void 0, void 0, function* () {
+                    props.callback(yield this.getTokenAccountInfo(props));
+                }));
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+}
+exports.TokenFaucet = TokenFaucet;

package/src/tx/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/tx/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInTx = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const COMPUTE_UNITS_DEFAULT = 200000;
+function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
+) {
+    const tx = new web3_js_1.Transaction();
+    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: computeUnits,
+            additionalFee: 0,
+        }));
+    }
+    return tx.add(instruction);
+}
+exports.wrapInTx = wrapInTx;

package/src/types.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderParams = exports.LiquidationType = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+const _1 = require(".");
+// # Utility Types / Enums / Constants
+class SwapDirection {
+}
+exports.SwapDirection = SwapDirection;
+SwapDirection.ADD = { add: {} };
+SwapDirection.REMOVE = { remove: {} };
+class BankBalanceType {
+}
+exports.BankBalanceType = BankBalanceType;
+BankBalanceType.DEPOSIT = { deposit: {} };
+BankBalanceType.BORROW = { borrow: {} };
+class PositionDirection {
+}
+exports.PositionDirection = PositionDirection;
+PositionDirection.LONG = { long: {} };
+PositionDirection.SHORT = { short: {} };
+class DepositDirection {
+}
+exports.DepositDirection = DepositDirection;
+DepositDirection.DEPOSIT = { deposit: {} };
+DepositDirection.WITHDRAW = { withdraw: {} };
+class OracleSource {
+}
+exports.OracleSource = OracleSource;
+OracleSource.PYTH = { pyth: {} };
+OracleSource.SWITCHBOARD = { switchboard: {} };
+OracleSource.QUOTE_ASSET = { quoteAsset: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+OrderType.MARKET = { market: {} };
+class OrderStatus {
+}
+exports.OrderStatus = OrderStatus;
+OrderStatus.INIT = { init: {} };
+OrderStatus.OPEN = { open: {} };
+class OrderDiscountTier {
+}
+exports.OrderDiscountTier = OrderDiscountTier;
+OrderDiscountTier.NONE = { none: {} };
+OrderDiscountTier.FIRST = { first: {} };
+OrderDiscountTier.SECOND = { second: {} };
+OrderDiscountTier.THIRD = { third: {} };
+OrderDiscountTier.FOURTH = { fourth: {} };
+class OrderAction {
+}
+exports.OrderAction = OrderAction;
+OrderAction.PLACE = { place: {} };
+OrderAction.CANCEL = { cancel: {} };
+OrderAction.EXPIRE = { expire: {} };
+OrderAction.FILL = { fill: {} };
+OrderAction.TRIGGER = { trigger: {} };
+class OrderActionExplanation {
+}
+exports.OrderActionExplanation = OrderActionExplanation;
+OrderActionExplanation.NONE = { none: {} };
+OrderActionExplanation.BREACHED_MARGIN_REQUIREMENT = {
+    breachedMarginRequirement: {},
+};
+OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+    oraclePriceBreachedLimitPrice: {},
+};
+OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+    marketOrderFilledToLimitPrice: {},
+};
+class OrderTriggerCondition {
+}
+exports.OrderTriggerCondition = OrderTriggerCondition;
+OrderTriggerCondition.ABOVE = { above: {} };
+OrderTriggerCondition.BELOW = { below: {} };
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
+function isOneOfVariant(object, types) {
+    return types.reduce((result, type) => {
+        return result || object.hasOwnProperty(type);
+    }, false);
+}
+exports.isOneOfVariant = isOneOfVariant;
+var TradeSide;
+(function (TradeSide) {
+    TradeSide[TradeSide["None"] = 0] = "None";
+    TradeSide[TradeSide["Buy"] = 1] = "Buy";
+    TradeSide[TradeSide["Sell"] = 2] = "Sell";
+})(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+class LiquidationType {
+}
+exports.LiquidationType = LiquidationType;
+LiquidationType.LIQUIDATE_PERP = { liquidatePerp: {} };
+LiquidationType.LIQUIDATE_BORROW = { liquidateBorrow: {} };
+LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
+    liquidateBorrowForPerpPnl: {},
+};
+LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+    liquidatePerpPnlForDeposit: {},
+};
+exports.DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    userOrderId: 0,
+    direction: PositionDirection.LONG,
+    baseAssetAmount: _1.ZERO,
+    price: _1.ZERO,
+    marketIndex: _1.ZERO,
+    reduceOnly: false,
+    postOnly: false,
+    immediateOrCancel: false,
+    triggerPrice: _1.ZERO,
+    triggerCondition: OrderTriggerCondition.ABOVE,
+    positionLimit: _1.ZERO,
+    oraclePriceOffset: _1.ZERO,
+    padding0: _1.ZERO,
+    padding1: _1.ZERO,
+    optionalAccounts: {
+        discountToken: false,
+        referrer: false,
+    },
+};

package/src/types.ts

@@ -458,6 +458,8 @@ export type UserStatsAccount = {
 		totalReferralReward: BN;
 		totalRefereeDiscount: BN;
 	};
+	authority: PublicKey;
+	referrer: PublicKey;
 };
 
 export type UserAccount = {

package/src/userName.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeName = exports.encodeName = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
+exports.MAX_NAME_LENGTH = 32;
+exports.DEFAULT_USER_NAME = 'Main Account';
+function encodeName(name) {
+    if (name.length > exports.MAX_NAME_LENGTH) {
+        throw Error(`User name (${name}) longer than 32 characters`);
+    }
+    const buffer = Buffer.alloc(32);
+    buffer.fill(name);
+    buffer.fill(' ', name.length);
+    return Array(...buffer);
+}
+exports.encodeName = encodeName;
+function decodeName(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer.toString('utf8').trim();
+}
+exports.decodeName = decodeName;