@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/browser/serum/serumSubscriber.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerumSubscriber = void 0;
+const serum_1 = require("@project-serum/serum");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+class SerumSubscriber {
+    constructor(config) {
+        this.connection = config.connection;
+        this.programId = config.programId;
+        this.marketAddress = config.marketAddress;
+        if (config.accountSubscription.type === 'polling') {
+            this.subscriptionType = 'polling';
+            this.accountLoader = config.accountSubscription.accountLoader;
+        }
+        else {
+            this.subscriptionType = 'websocket';
+        }
+    }
+    async subscribe() {
+        if (this.subscribed) {
+            return;
+        }
+        this.market = await serum_1.Market.load(this.connection, this.marketAddress, undefined, this.programId);
+        this.asksAddress = this.market.asksAddress;
+        this.asks = await this.market.loadAsks(this.connection);
+        if (this.subscriptionType === 'websocket') {
+            this.asksCallbackId = this.connection.onAccountChange(this.asksAddress, (accountInfo, ctx) => {
+                this.lastAsksSlot = ctx.slot;
+                this.asks = serum_1.Orderbook.decode(this.market, accountInfo.data);
+            });
+        }
+        else {
+            this.asksCallbackId = await this.accountLoader.addAccount(this.asksAddress, (buffer, slot) => {
+                this.lastAsksSlot = slot;
+                this.asks = serum_1.Orderbook.decode(this.market, buffer);
+            });
+        }
+        this.bidsAddress = this.market.bidsAddress;
+        this.bids = await this.market.loadBids(this.connection);
+        if (this.subscriptionType === 'websocket') {
+            this.bidsCallbackId = this.connection.onAccountChange(this.bidsAddress, (accountInfo, ctx) => {
+                this.lastBidsSlot = ctx.slot;
+                this.bids = serum_1.Orderbook.decode(this.market, accountInfo.data);
+            });
+        }
+        else {
+            this.bidsCallbackId = await this.accountLoader.addAccount(this.bidsAddress, (buffer, slot) => {
+                this.lastBidsSlot = slot;
+                this.bids = serum_1.Orderbook.decode(this.market, buffer);
+            });
+        }
+        this.subscribed = true;
+    }
+    getBestBid() {
+        const bestBid = this.bids.getL2(1)[0];
+        if (!bestBid) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestBid[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
+    getBestAsk() {
+        const bestAsk = this.asks.getL2(1)[0];
+        if (!bestAsk) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestAsk[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
+    getL2Bids() {
+        return this.getL2Levels('bids');
+    }
+    getL2Asks() {
+        return this.getL2Levels('asks');
+    }
+    *getL2Levels(side) {
+        // @ts-ignore
+        const basePrecision = Math.pow(10, this.market._baseSplTokenDecimals);
+        const pricePrecision = numericConstants_1.PRICE_PRECISION.toNumber();
+        for (const { price: priceNum, size: sizeNum } of this[side].items(side === 'bids')) {
+            const price = new anchor_1.BN(priceNum * pricePrecision);
+            const size = new anchor_1.BN(sizeNum * basePrecision);
+            yield {
+                price,
+                size,
+                sources: {
+                    serum: size,
+                },
+            };
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscribed) {
+            return;
+        }
+        // remove listeners
+        if (this.subscriptionType === 'websocket') {
+            await this.connection.removeAccountChangeListener(this.asksCallbackId);
+            await this.connection.removeAccountChangeListener(this.bidsCallbackId);
+        }
+        else {
+            this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+            this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+        }
+        this.subscribed = false;
+    }
+}
+exports.SerumSubscriber = SerumSubscriber;

package/lib/browser/serum/types.d.ts

@@ -0,0 +1,13 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+export type SerumMarketSubscriberConfig = {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountSubscription: {
+        type: 'polling';
+        accountLoader: BulkAccountLoader;
+    } | {
+        type: 'websocket';
+    };
+};

package/lib/browser/serum/types.js

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

package/lib/browser/slot/SlotSubscriber.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+type SlotSubscriberConfig = {
+    resubTimeoutMs?: number;
+};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
+export declare class SlotSubscriber {
+    private connection;
+    currentSlot: number;
+    subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
+    timeoutId?: NodeJS.Timeout;
+    resubTimeoutMs?: number;
+    isUnsubscribing: boolean;
+    receivingData: boolean;
+    constructor(connection: Connection, config?: SlotSubscriberConfig);
+    subscribe(): Promise<void>;
+    private setTimeout;
+    getSlot(): number;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}
+export {};

package/lib/browser/slot/SlotSubscriber.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotSubscriber = void 0;
+const events_1 = require("events");
+class SlotSubscriber {
+    constructor(connection, config) {
+        this.connection = connection;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubTimeoutMs = config === null || config === void 0 ? void 0 : config.resubTimeoutMs;
+        if (this.resubTimeoutMs < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+    }
+    async subscribe() {
+        if (this.subscriptionId != null) {
+            return;
+        }
+        this.currentSlot = await this.connection.getSlot('confirmed');
+        this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+            if (!this.currentSlot || this.currentSlot < slotInfo.slot) {
+                if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                }
+                this.currentSlot = slotInfo.slot;
+                this.eventEmitter.emit('newSlot', slotInfo.slot);
+            }
+        });
+        if (this.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`);
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe();
+            }
+        }, this.resubTimeoutMs);
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            await this.connection.removeSlotChangeListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+            this.isUnsubscribing = false;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

package/lib/browser/slot/SlothashSubscriber.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { Commitment, Connection } from '@solana/web3.js';
+type SlothashSubscriberConfig = {
+    resubTimeoutMs?: number;
+    commitment?: Commitment;
+};
+export type Slothash = {
+    slot: number;
+    hash: string;
+};
+export declare class SlothashSubscriber {
+    private connection;
+    currentSlothash: Slothash;
+    subscriptionId: number;
+    commitment: Commitment;
+    timeoutId?: NodeJS.Timeout;
+    resubTimeoutMs?: number;
+    isUnsubscribing: boolean;
+    receivingData: boolean;
+    constructor(connection: Connection, config?: SlothashSubscriberConfig);
+    subscribe(): Promise<void>;
+    private setTimeout;
+    getSlothash(): Slothash;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}
+export {};

package/lib/browser/slot/SlothashSubscriber.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlothashSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const anchor_1 = require("@coral-xyz/anchor");
+class SlothashSubscriber {
+    constructor(connection, config) {
+        var _a;
+        this.connection = connection;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.resubTimeoutMs = config === null || config === void 0 ? void 0 : config.resubTimeoutMs;
+        this.commitment = (_a = config === null || config === void 0 ? void 0 : config.commitment) !== null && _a !== void 0 ? _a : 'processed';
+        if (this.resubTimeoutMs < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+    }
+    async subscribe() {
+        if (this.subscriptionId != null) {
+            return;
+        }
+        const currentAccountData = await this.connection.getAccountInfo(web3_js_1.SYSVAR_SLOT_HASHES_PUBKEY, this.commitment);
+        if (currentAccountData == null) {
+            throw new Error('Failed to retrieve current slot hash');
+        }
+        this.currentSlothash = deserializeSlothash(currentAccountData.data);
+        this.subscriptionId = this.connection.onAccountChange(web3_js_1.SYSVAR_SLOT_HASHES_PUBKEY, (slothashInfo, context) => {
+            if (!this.currentSlothash || this.currentSlothash.slot < context.slot) {
+                if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                }
+                this.currentSlothash = deserializeSlothash(slothashInfo.data);
+            }
+        }, this.commitment);
+        if (this.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`);
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe();
+            }
+        }, this.resubTimeoutMs);
+    }
+    getSlothash() {
+        return this.currentSlothash;
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            await this.connection.removeSlotChangeListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+            this.isUnsubscribing = false;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.SlothashSubscriber = SlothashSubscriber;
+function deserializeSlothash(data) {
+    const slotNumber = new anchor_1.BN(data.subarray(8, 16), 10, 'le');
+    const hash = bytes_1.bs58.encode(data.subarray(16, 48));
+    return {
+        slot: slotNumber.toNumber(),
+        hash,
+    };
+}

package/lib/browser/testClient.d.ts

@@ -0,0 +1,8 @@
+import { AdminClient } from './adminClient';
+import { ConfirmOptions, Signer, Transaction } from '@solana/web3.js';
+import { TxSigAndSlot } from './tx/types';
+import { DriftClientConfig } from './driftClientConfig';
+export declare class TestClient extends AdminClient {
+    constructor(config: DriftClientConfig);
+    sendTransaction(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+}

package/lib/browser/testClient.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestClient = void 0;
+const adminClient_1 = require("./adminClient");
+class TestClient extends adminClient_1.AdminClient {
+    constructor(config) {
+        if (config.accountSubscription.type !== 'polling') {
+            throw new Error('Test client must be polling');
+        }
+        super(config);
+    }
+    async sendTransaction(tx, additionalSigners, opts, preSigned) {
+        const { txSig, slot } = await super.sendTransaction(tx, additionalSigners, opts, preSigned);
+        let lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        await this.fetchAccounts();
+        while (lastFetchedSlot < slot) {
+            await this.fetchAccounts();
+            lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        }
+        return { txSig, slot };
+    }
+}
+exports.TestClient = TestClient;

package/lib/browser/token/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Account } from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+export declare function parseTokenAccount(data: Buffer, pubkey: PublicKey): Account;

package/lib/browser/token/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+function parseTokenAccount(data, pubkey) {
+    // mock AccountInfo so unpackAccount can be used
+    const accountInfo = {
+        data,
+        owner: spl_token_1.TOKEN_PROGRAM_ID,
+        executable: false,
+        lamports: 0,
+    };
+    return (0, spl_token_1.unpackAccount)(pubkey, accountInfo, spl_token_1.TOKEN_PROGRAM_ID);
+}
+exports.parseTokenAccount = parseTokenAccount;

package/lib/browser/tokenFaucet.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="bn.js" />
+import * as anchor from '@coral-xyz/anchor';
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import { Account } from '@solana/spl-token';
+import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import { BN } from '.';
+import { IWallet } from './types';
+import { BankrunContextWrapper } from './bankrun/bankrunConnection';
+export declare class TokenFaucet {
+    context?: BankrunContextWrapper;
+    connection: Connection;
+    wallet: IWallet;
+    program: Program;
+    provider: AnchorProvider;
+    mint: PublicKey;
+    opts?: ConfirmOptions;
+    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, mint: PublicKey, opts?: ConfirmOptions, context?: BankrunContextWrapper);
+    getFaucetConfigPublicKeyAndNonce(): Promise<[
+        PublicKey,
+        number
+    ]>;
+    getMintAuthority(): Promise<PublicKey>;
+    getFaucetConfigPublicKey(): Promise<PublicKey>;
+    initialize(): Promise<TransactionSignature>;
+    fetchState(): Promise<any>;
+    private mintToUserIx;
+    mintToUser(userTokenAccount: PublicKey, amount: BN): Promise<TransactionSignature>;
+    transferMintAuthority(): Promise<TransactionSignature>;
+    createAssociatedTokenAccountAndMintTo(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionSignature]>;
+    createAssociatedTokenAccountAndMintToInstructions(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionInstruction, TransactionInstruction]>;
+    getAssosciatedMockUSDMintAddress(props: {
+        userPubKey: PublicKey;
+    }): Promise<anchor.web3.PublicKey>;
+    getTokenAccountInfo(props: {
+        userPubKey: PublicKey;
+    }): Promise<Account>;
+    subscribeToTokenAccount(props: {
+        userPubKey: PublicKey;
+        callback: (accountInfo: Account) => void;
+    }): Promise<boolean>;
+}

package/lib/browser/tokenFaucet.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 __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("@coral-xyz/anchor"));
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const _1 = require(".");
+const token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
+class TokenFaucet {
+    constructor(connection, wallet, programId, mint, opts, context) {
+        this.connection = connection;
+        this.context = context;
+        this.wallet = wallet;
+        this.opts = opts || _1.DEFAULT_CONFIRMATION_OPTS;
+        // @ts-ignore
+        const provider = new anchor_1.AnchorProvider(context ? context.connection.toConnection() : this.connection, 
+        // @ts-ignore
+        wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
+    }
+    async getFaucetConfigPublicKeyAndNonce() {
+        return anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+            this.mint.toBuffer(),
+        ], this.program.programId);
+    }
+    async getMintAuthority() {
+        return (await anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+            this.mint.toBuffer(),
+        ], this.program.programId))[0];
+    }
+    async getFaucetConfigPublicKey() {
+        return (await this.getFaucetConfigPublicKeyAndNonce())[0];
+    }
+    async initialize() {
+        const [faucetConfigPublicKey] = await this.getFaucetConfigPublicKeyAndNonce();
+        const ix = this.program.instruction.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,
+            },
+        });
+        const tx = new web3_js_1.Transaction().add(ix);
+        const txSig = await this.context.sendTransaction(tx);
+        return txSig;
+    }
+    async fetchState() {
+        return await this.program.account.faucetConfig.fetch(await this.getFaucetConfigPublicKey());
+    }
+    async mintToUserIx(userTokenAccount, amount) {
+        return this.program.instruction.mintToUser(amount, {
+            accounts: {
+                faucetConfig: await this.getFaucetConfigPublicKey(),
+                mintAccount: this.mint,
+                userTokenAccount,
+                mintAuthority: await this.getMintAuthority(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+    }
+    async mintToUser(userTokenAccount, amount) {
+        const mintIx = await this.mintToUserIx(userTokenAccount, amount);
+        const tx = new web3_js_1.Transaction().add(mintIx);
+        if (this.context) {
+            return await this.context.sendTransaction(tx);
+        }
+        else {
+            return await this.program.provider.sendAndConfirm(tx, [], this.opts);
+        }
+    }
+    async transferMintAuthority() {
+        if (this.context) {
+            const ix = this.program.instruction.transferMintAuthority({
+                accounts: {
+                    faucetConfig: await this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    mintAuthority: await this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    admin: this.wallet.publicKey,
+                },
+            });
+            const tx = new web3_js_1.Transaction().add(ix);
+            const txSig = await this.context.sendTransaction(tx);
+            return txSig;
+        }
+        return await this.program.rpc.transferMintAuthority({
+            accounts: {
+                faucetConfig: await this.getFaucetConfigPublicKey(),
+                mintAccount: this.mint,
+                mintAuthority: await this.getMintAuthority(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                admin: this.wallet.publicKey,
+            },
+        });
+    }
+    async createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        const tx = new web3_js_1.Transaction();
+        const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = await this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+        let associatedTokenAccountExists = false;
+        try {
+            const assosciatedTokenAccount = await this.context.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);
+        let txSig;
+        if (this.context) {
+            txSig = await this.context.sendTransaction(tx);
+        }
+        else {
+            txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+        }
+        return [associatedTokenPublicKey, txSig];
+    }
+    async createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
+        const state = await this.fetchState();
+        const associateTokenPublicKey = await this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
+        const createAssociatedAccountIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(this.wallet.publicKey, associateTokenPublicKey, userPublicKey, state.mint);
+        const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
+        return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+    }
+    async getAssosciatedMockUSDMintAddress(props) {
+        const state = await this.fetchState();
+        return (0, spl_token_1.getAssociatedTokenAddress)(state.mint, props.userPubKey);
+    }
+    async getTokenAccountInfo(props) {
+        const associatedKey = await this.getAssosciatedMockUSDMintAddress(props);
+        if (this.context) {
+            return await this.context.connection.getTokenAccount(associatedKey);
+        }
+        return await (0, spl_token_1.getAccount)(this.connection, associatedKey);
+    }
+    async subscribeToTokenAccount(props) {
+        try {
+            const tokenAccountKey = await this.getAssosciatedMockUSDMintAddress(props);
+            props.callback(await this.getTokenAccountInfo(props));
+            // Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
+            this.context.connection.onAccountChange(tokenAccountKey, async (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => {
+                props.callback(await this.getTokenAccountInfo(props));
+            });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.TokenFaucet = TokenFaucet;