@drift-labs/sdk 2.97.0-beta.9 → 2.98.0-beta.1

package/lib/node/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/node/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/node/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/node/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/node/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/node/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/node/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;

package/lib/node/tx/baseTxSender.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
+import NodeCache from 'node-cache';
+export declare abstract class BaseTxSender implements TxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    additionalConnections: Connection[];
+    timeoutCount: number;
+    confirmationStrategy: ConfirmationStrategy;
+    additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
+    txHandler: TxHandler;
+    trackTxLandRate?: boolean;
+    throwOnTimeoutError: boolean;
+    lookbackWindowMinutes: number;
+    txSigCache?: NodeCache;
+    txLandRate: number;
+    lastPriorityFeeSuggestion: number;
+    landRateToFeeFunc: (landRate: number) => number;
+    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        additionalConnections?: any;
+        confirmationStrategy?: ConfirmationStrategy;
+        additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+        txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
+        throwOnTimeoutError?: boolean;
+    });
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], _additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: BlockhashWithExpiryBlockHeight): Promise<VersionedTransaction>;
+    sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+    simulateTransaction(tx: VersionedTransaction): Promise<boolean>;
+    confirmTransactionWebSocket(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    confirmTransactionPolling(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult> | undefined>;
+    confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    getTimestamp(): number;
+    promiseTimeout<T>(promises: Promise<T>[], timeoutMs: number): Promise<T | null>;
+    sendToAdditionalConnections(rawTx: Buffer | Uint8Array, opts: ConfirmOptions): void;
+    addAdditionalConnection(newConnection: Connection): void;
+    getTimeoutCount(): number;
+    checkConfirmationResultForError(txSig: string, result: SignatureResult): Promise<void>;
+    getTxLandRate(): number;
+    private defaultLandRateToFeeFunc;
+    getSuggestedPriorityFeeMultiplier(): number;
+}