@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.30

package/lib/math/trade.js

@@ -19,13 +19,13 @@ const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
  * @param useSpread whether to consider spread with calculating slippage
  * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
  *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
  *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
 function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
     let oldPrice;
@@ -38,20 +38,16 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
         }
     }
     else {
-        oldPrice = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+        oldPrice = (0, market_1.calculateReservePrice)(market, oraclePriceData);
     }
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
-    const swapDirection = (0, types_2.isVariant)(direction, 'long')
-        ? types_1.SwapDirection.REMOVE
-        : types_1.SwapDirection.ADD;
-    const quoteAssetAmountAcquired = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), market.amm.pegMultiplier, swapDirection);
-    const entryPrice = quoteAssetAmountAcquired
+    const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
+    const entryPrice = acquiredQuoteAssetAmount
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(acquiredBase.abs());
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(acquiredBaseReserve.abs());
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
         const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
@@ -65,7 +61,7 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     else {
         amm = market.amm;
     }
-    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBase), amm.quoteAssetReserve.sub(acquiredQuote), amm.pegMultiplier);
+    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
         (0, assert_1.assert)(newPrice.lte(oldPrice));
     }
@@ -74,12 +70,12 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     }
     const pctMaxSlippage = newPrice
         .sub(oldPrice)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(oldPrice)
         .abs();
     const pctAvgSlippage = entryPrice
         .sub(oldPrice)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(oldPrice)
         .abs();
     return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice];
@@ -98,7 +94,7 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  */
 function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
     if (amount.eq(numericConstants_1.ZERO)) {
-        return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
     const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
     let amm;
@@ -117,7 +113,8 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection);
     const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    return [acquiredBase, acquiredQuote];
+    const acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**
@@ -133,15 +130,15 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  * [
  *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
  * ]
  */
 function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote', oraclePriceData, useSpread = true) {
     (0, assert_1.assert)(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
     (0, assert_1.assert)(targetPrice.gt(numericConstants_1.ZERO));
     (0, assert_1.assert)(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
-    const markPriceBefore = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+    const markPriceBefore = (0, market_1.calculateReservePrice)(market, oraclePriceData);
     const bidPriceBefore = (0, market_1.calculateBidPrice)(market, oraclePriceData);
     const askPriceBefore = (0, market_1.calculateAskPrice)(market, oraclePriceData);
     let direction;
@@ -173,7 +170,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         quoteAssetReserveBefore = market.amm.quoteAssetReserve;
     }
     const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
+    const k = invariant.mul(numericConstants_1.PRICE_PRECISION);
     let baseAssetReserveAfter;
     let quoteAssetReserveAfter;
     const biasModifier = new anchor_1.BN(1);
@@ -194,9 +191,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     else if (markPriceBefore.gt(targetPrice)) {
         // overestimate y2
         baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
-        quoteAssetReserveAfter = k
-            .div(numericConstants_1.MARK_PRICE_PRECISION)
-            .div(baseAssetReserveAfter);
+        quoteAssetReserveAfter = k.div(numericConstants_1.PRICE_PRECISION).div(baseAssetReserveAfter);
         markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.SHORT;
         tradeSize = quoteAssetReserveBefore
@@ -209,9 +204,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     else if (markPriceBefore.lt(targetPrice)) {
         // underestimate y2
         baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
-        quoteAssetReserveAfter = k
-            .div(numericConstants_1.MARK_PRICE_PRECISION)
-            .div(baseAssetReserveAfter);
+        quoteAssetReserveAfter = k.div(numericConstants_1.PRICE_PRECISION).div(baseAssetReserveAfter);
         markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.LONG;
         tradeSize = quoteAssetReserveAfter
@@ -237,7 +230,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     const entryPrice = tradeSize
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(baseSize.abs());
     (0, assert_1.assert)(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
     (0, assert_1.assert)(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +

package/lib/oracles/pythClient.js

@@ -29,7 +29,7 @@ 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)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(pythPrecision);
 }
 exports.convertPythPrice = convertPythPrice;

package/lib/oracles/quoteAssetOracleClient.js

@@ -4,7 +4,7 @@ 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,
+    price: numericConstants_1.PRICE_PRECISION,
     slot: new anchor_1.BN(0),
     confidence: new anchor_1.BN(1),
     hasSufficientNumberOfDataPoints: true,

package/lib/oracles/switchboardClient.js

@@ -53,6 +53,6 @@ function getSwitchboardProgram(connection) {
 function convertSwitchboardDecimal(switchboardDecimal) {
     const switchboardPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(switchboardDecimal.scale));
     return switchboardDecimal.mantissa
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(switchboardPrecision);
 }

package/lib/orderParams.d.ts

@@ -1,7 +1,16 @@
 /// <reference types="bn.js" />
-import { OrderParams, OrderTriggerCondition, PositionDirection } from './types';
+import { OptionalOrderParams, OrderTriggerCondition } from './types';
 import { BN } from '@project-serum/anchor';
-export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number, postOnly?: boolean, oraclePriceOffset?: BN, immediateOrCancel?: boolean): OrderParams;
-export declare function getTriggerMarketOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
-export declare function getTriggerLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
-export declare function getMarketOrderParams(marketIndex: BN, direction: PositionDirection, quoteAssetAmount: BN, baseAssetAmount: BN, reduceOnly: boolean, price?: BN, discountToken?: boolean, referrer?: boolean): OrderParams;
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+    price: BN;
+}): OptionalOrderParams;
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+}): OptionalOrderParams;
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+    price: BN;
+}): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'>): OptionalOrderParams;

package/lib/orderParams.js

@@ -2,107 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
-const numericConstants_1 = require("./constants/numericConstants");
-function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO, immediateOrCancel = false) {
-    return {
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, {
         orderType: types_1.OrderType.LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly,
-        immediateOrCancel,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset,
-    };
+    });
 }
 exports.getLimitOrderParams = getLimitOrderParams;
-function getTriggerMarketOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, {
         orderType: types_1.OrderType.TRIGGER_MARKET,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price: numericConstants_1.ZERO,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+    });
 }
 exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
-function getTriggerLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, {
         orderType: types_1.OrderType.TRIGGER_LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+    });
 }
 exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
-function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAssetAmount, reduceOnly, price = numericConstants_1.ZERO, discountToken = false, referrer = false) {
-    if (baseAssetAmount.eq(numericConstants_1.ZERO) && quoteAssetAmount.eq(numericConstants_1.ZERO)) {
-        throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-    }
-    return {
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, {
         orderType: types_1.OrderType.MARKET,
-        userOrderId: 0,
-        marketIndex,
-        direction,
-        quoteAssetAmount,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+    });
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/serum/serumSubscriber.d.ts

@@ -0,0 +1,23 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { Market, Orderbook } from '@project-serum/serum';
+import { SerumMarketSubscriberConfig } from './types';
+export declare class SerumSubscriber {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountLoader: BulkAccountLoader;
+    market: Market;
+    subscribed: boolean;
+    asksAddress: PublicKey;
+    asks: Orderbook;
+    asksCallbackId: string;
+    lastAsksSlot: number;
+    bidsAddress: PublicKey;
+    bids: Orderbook;
+    bidsCallbackId: string;
+    lastBidsSlot: number;
+    constructor(config: SerumMarketSubscriberConfig);
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/serum/serumSubscriber.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerumSubscriber = void 0;
+const serum_1 = require("@project-serum/serum");
+class SerumSubscriber {
+    constructor(config) {
+        this.connection = config.connection;
+        this.programId = config.programId;
+        this.marketAddress = config.marketAddress;
+        this.accountLoader = config.accountSubscription.accountLoader;
+    }
+    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);
+        this.asksCallbackId = this.accountLoader.addAccount(this.asksAddress, (buffer, slot) => {
+            this.lastAsksSlot = slot;
+            this.asks = serum_1.Orderbook.decode(this.market, buffer);
+            console.log(this.asks.getL2(3));
+        });
+        this.bidsAddress = this.market.bidsAddress;
+        this.bids = await this.market.loadBids(this.connection);
+        this.bidsCallbackId = this.accountLoader.addAccount(this.bidsAddress, (buffer, slot) => {
+            this.lastBidsSlot = slot;
+            this.bids = serum_1.Orderbook.decode(this.market, buffer);
+        });
+        this.subscribed = true;
+    }
+    async unsubscribe() {
+        if (!this.subscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+        this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+        this.subscribed = false;
+    }
+}
+exports.SerumSubscriber = SerumSubscriber;

package/lib/serum/types.d.ts

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

package/lib/serum/types.js

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

package/lib/slot/SlotSubscriber.d.ts

@@ -1,9 +1,16 @@
+/// <reference types="node" />
 import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 declare type SlotSubscriberConfig = {};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
 export declare class SlotSubscriber {
     private connection;
     currentSlot: number;
     subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
     constructor(connection: Connection, _config?: SlotSubscriberConfig);
     subscribe(): Promise<void>;
     getSlot(): number;

package/lib/slot/SlotSubscriber.js

@@ -1,14 +1,17 @@
 "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.eventEmitter = new events_1.EventEmitter();
     }
     async subscribe() {
         this.currentSlot = await this.connection.getSlot('confirmed');
         this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
             this.currentSlot = slotInfo.slot;
+            this.eventEmitter.emit('newSlot', slotInfo.slot);
         });
     }
     getSlot() {

package/lib/{mockUSDCFaucet.d.ts → tokenFaucet.d.ts}

@@ -5,22 +5,25 @@ import { AccountInfo } from '@solana/spl-token';
 import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
 import { BN } from '.';
 import { IWallet } from './types';
-export declare class MockUSDCFaucet {
+export declare class TokenFaucet {
     connection: Connection;
     wallet: IWallet;
     program: Program;
     provider: AnchorProvider;
+    mint: PublicKey;
     opts?: ConfirmOptions;
-    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, opts?: ConfirmOptions);
-    getMockUSDCFaucetStatePublicKeyAndNonce(): Promise<[
+    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, mint: PublicKey, opts?: ConfirmOptions);
+    getFaucetConfigPublicKeyAndNonce(): Promise<[
         PublicKey,
         number
     ]>;
-    mockUSDCFaucetStatePublicKey?: PublicKey;
-    getMockUSDCFaucetStatePublicKey(): Promise<PublicKey>;
+    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: {

package/lib/{mockUSDCFaucet.js → tokenFaucet.js}

@@ -26,77 +26,97 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockUSDCFaucet = void 0;
+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 mock_usdc_faucet_json_1 = __importDefault(require("./idl/mock_usdc_faucet.json"));
-class MockUSDCFaucet {
-    constructor(connection, wallet, programId, opts) {
+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(mock_usdc_faucet_json_1.default, programId, provider);
+        this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
     }
-    async getMockUSDCFaucetStatePublicKeyAndNonce() {
-        return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('mock_usdc_faucet'))], this.program.programId);
+    async getFaucetConfigPublicKeyAndNonce() {
+        return anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+            this.mint.toBuffer(),
+        ], this.program.programId);
     }
-    async getMockUSDCFaucetStatePublicKey() {
-        if (this.mockUSDCFaucetStatePublicKey) {
-            return this.mockUSDCFaucetStatePublicKey;
-        }
-        this.mockUSDCFaucetStatePublicKey = (await this.getMockUSDCFaucetStatePublicKeyAndNonce())[0];
-        return this.mockUSDCFaucetStatePublicKey;
+    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 stateAccountRPCResponse = await this.connection.getParsedAccountInfo(await this.getMockUSDCFaucetStatePublicKey());
-        if (stateAccountRPCResponse.value !== null) {
-            throw new Error('Faucet already initialized');
-        }
-        const fakeUSDCMint = anchor.web3.Keypair.generate();
-        const createUSDCMintAccountIx = web3_js_1.SystemProgram.createAccount({
-            fromPubkey: this.wallet.publicKey,
-            newAccountPubkey: fakeUSDCMint.publicKey,
-            lamports: await spl_token_1.Token.getMinBalanceRentForExemptMint(this.connection),
-            space: spl_token_1.MintLayout.span,
-            programId: spl_token_1.TOKEN_PROGRAM_ID,
-        });
-        const [mintAuthority, _mintAuthorityNonce] = await web3_js_1.PublicKey.findProgramAddress([fakeUSDCMint.publicKey.toBuffer()], this.program.programId);
-        const initUSDCMintIx = spl_token_1.Token.createInitMintInstruction(spl_token_1.TOKEN_PROGRAM_ID, fakeUSDCMint.publicKey, 6, mintAuthority, null);
-        const [mockUSDCFaucetStatePublicKey, mockUSDCFaucetStateNonce] = await this.getMockUSDCFaucetStatePublicKeyAndNonce();
-        return await this.program.rpc.initialize(mockUSDCFaucetStateNonce, {
+        const [faucetConfigPublicKey] = await this.getFaucetConfigPublicKeyAndNonce();
+        return await this.program.rpc.initialize({
             accounts: {
-                mockUsdcFaucetState: mockUSDCFaucetStatePublicKey,
+                faucetConfig: faucetConfigPublicKey,
                 admin: this.wallet.publicKey,
-                mintAccount: fakeUSDCMint.publicKey,
+                mintAccount: this.mint,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
                 systemProgram: anchor.web3.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
-            instructions: [createUSDCMintAccountIx, initUSDCMintIx],
-            signers: [fakeUSDCMint],
         });
     }
     async fetchState() {
-        return await this.program.account.mockUsdcFaucetState.fetch(await this.getMockUSDCFaucetStatePublicKey());
+        return await this.program.account.faucetConfig.fetch(await this.getFaucetConfigPublicKey());
     }
-    async mintToUser(userTokenAccount, amount) {
-        const state = await this.fetchState();
-        return await this.program.rpc.mintToUser(amount, {
+    async mintToUserIx(userTokenAccount, amount) {
+        return this.program.instruction.mintToUser(amount, {
             accounts: {
-                mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
-                mintAccount: state.mint,
+                faucetConfig: await this.getFaucetConfigPublicKey(),
+                mintAccount: this.mint,
                 userTokenAccount,
-                mintAuthority: state.mintAuthority,
+                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);
+        const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+        return txSig;
+    }
+    async transferMintAuthority() {
+        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);
-        const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToTx);
+        let associatedTokenAccountExists = false;
+        try {
+            const assosciatedTokenAccount = await 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 = await this.program.provider.sendAndConfirm(tx, [], this.opts);
         return [associatedTokenPublicKey, txSig];
     }
@@ -104,15 +124,7 @@ class MockUSDCFaucet {
         const state = await this.fetchState();
         const associateTokenPublicKey = await 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 = await this.program.instruction.mintToUser(amount, {
-            accounts: {
-                mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
-                mintAccount: state.mint,
-                userTokenAccount: associateTokenPublicKey,
-                mintAuthority: state.mintAuthority,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
+        const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
         return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
     }
     async getAssosciatedMockUSDMintAddress(props) {
@@ -143,4 +155,4 @@ class MockUSDCFaucet {
         }
     }
 }
-exports.MockUSDCFaucet = MockUSDCFaucet;
+exports.TokenFaucet = TokenFaucet;

package/lib/tx/retryTxSender.d.ts

@@ -11,7 +11,7 @@ export declare class RetryTxSender implements TxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     constructor(provider: AnchorProvider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
     getTimestamp(): number;