@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/src/orders.ts

@@ -1,245 +0,0 @@
-import {
-	isVariant,
-	MarketAccount,
-	Order,
-	PositionDirection,
-	UserAccount,
-	UserPosition,
-} from './types';
-import { BN, standardizeBaseAssetAmount } from '.';
-import { calculateNewMarketAfterTrade } from './math/market';
-import {
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	PEG_PRECISION,
-	ZERO,
-} from './constants/numericConstants';
-import { calculateMaxBaseAssetAmountToTrade } from './math/amm';
-import {
-	findDirectionToClose,
-	positionCurrentDirection,
-} from './math/position';
-import { OraclePriceData } from '.';
-
-export function calculateNewStateAfterOrder(
-	userAccount: UserAccount,
-	userPosition: UserPosition,
-	market: MarketAccount,
-	order: Order
-): [UserAccount, UserPosition, MarketAccount] | null {
-	if (isVariant(order.status, 'init')) {
-		return null;
-	}
-
-	const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(
-		market,
-		order
-	);
-	if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-		return null;
-	}
-
-	const userAccountAfter = Object.assign({}, userAccount);
-	const userPositionAfter = Object.assign({}, userPosition);
-
-	const currentPositionDirection = positionCurrentDirection(userPosition);
-	const increasePosition =
-		userPosition.baseAssetAmount.eq(ZERO) ||
-		isSameDirection(order.direction, currentPositionDirection);
-
-	if (increasePosition) {
-		const marketAfter = calculateNewMarketAfterTrade(
-			baseAssetAmountToTrade,
-			order.direction,
-			market
-		);
-
-		const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
-			calculateAmountSwapped(market, marketAfter);
-
-		userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
-			baseAssetAmountSwapped
-		);
-		userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(
-			quoteAssetAmountSwapped
-		);
-
-		return [userAccountAfter, userPositionAfter, marketAfter];
-	} else {
-		const reversePosition = baseAssetAmountToTrade.gt(
-			userPosition.baseAssetAmount.abs()
-		);
-
-		if (reversePosition) {
-			const intermediateMarket = calculateNewMarketAfterTrade(
-				userPosition.baseAssetAmount,
-				findDirectionToClose(userPosition),
-				market
-			);
-
-			const { quoteAssetAmountSwapped: baseAssetValue } =
-				calculateAmountSwapped(market, intermediateMarket);
-
-			let pnl;
-			if (isVariant(currentPositionDirection, 'long')) {
-				pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-			} else {
-				pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-			}
-
-			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-
-			const baseAssetAmountLeft = baseAssetAmountToTrade.sub(
-				userPosition.baseAssetAmount.abs()
-			);
-
-			const marketAfter = calculateNewMarketAfterTrade(
-				baseAssetAmountLeft,
-				order.direction,
-				intermediateMarket
-			);
-
-			const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
-				calculateAmountSwapped(intermediateMarket, marketAfter);
-
-			userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-			userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-
-			return [userAccountAfter, userPositionAfter, marketAfter];
-		} else {
-			const marketAfter = calculateNewMarketAfterTrade(
-				baseAssetAmountToTrade,
-				order.direction,
-				market
-			);
-
-			const {
-				quoteAssetAmountSwapped: baseAssetValue,
-				baseAssetAmountSwapped,
-			} = calculateAmountSwapped(market, marketAfter);
-
-			const costBasisRealized = userPosition.quoteAssetAmount
-				.mul(baseAssetAmountSwapped.abs())
-				.div(userPosition.baseAssetAmount.abs());
-
-			let pnl;
-			if (isVariant(currentPositionDirection, 'long')) {
-				pnl = baseAssetValue.sub(costBasisRealized);
-			} else {
-				pnl = costBasisRealized.sub(baseAssetValue);
-			}
-
-			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-
-			userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
-				baseAssetAmountSwapped
-			);
-			userPositionAfter.quoteAssetAmount =
-				userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-
-			return [userAccountAfter, userPositionAfter, marketAfter];
-		}
-	}
-}
-
-function calculateAmountSwapped(
-	marketBefore: MarketAccount,
-	marketAfter: MarketAccount
-): { quoteAssetAmountSwapped: BN; baseAssetAmountSwapped: BN } {
-	return {
-		quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-			.sub(marketAfter.amm.quoteAssetReserve)
-			.abs()
-			.mul(marketBefore.amm.pegMultiplier)
-			.div(PEG_PRECISION)
-			.div(AMM_TO_QUOTE_PRECISION_RATIO),
-		baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(
-			marketAfter.amm.baseAssetReserve
-		),
-	};
-}
-
-export function calculateBaseAssetAmountMarketCanExecute(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): BN {
-	if (isVariant(order.orderType, 'limit')) {
-		return calculateAmountToTradeForLimit(market, order, oraclePriceData);
-	} else if (isVariant(order.orderType, 'triggerLimit')) {
-		return calculateAmountToTradeForTriggerLimit(market, order);
-	} else if (isVariant(order.orderType, 'market')) {
-		return ZERO;
-	} else {
-		return calculateAmountToTradeForTriggerMarket(market, order);
-	}
-}
-
-export function calculateAmountToTradeForLimit(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): BN {
-	let limitPrice = order.price;
-	if (!order.oraclePriceOffset.eq(ZERO)) {
-		if (!oraclePriceData) {
-			throw Error(
-				'Cant calculate limit price for oracle offset oracle without OraclePriceData'
-			);
-		}
-		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-	}
-
-	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
-		market.amm,
-		limitPrice,
-		order.direction,
-		oraclePriceData
-	);
-
-	const baseAssetAmount = standardizeBaseAssetAmount(
-		maxAmountToTrade,
-		market.amm.baseAssetAmountStepSize
-	);
-
-	// Check that directions are the same
-	const sameDirection = isSameDirection(direction, order.direction);
-	if (!sameDirection) {
-		return ZERO;
-	}
-
-	return baseAssetAmount.gt(order.baseAssetAmount)
-		? order.baseAssetAmount
-		: baseAssetAmount;
-}
-
-export function calculateAmountToTradeForTriggerLimit(
-	market: MarketAccount,
-	order: Order
-): BN {
-	if (!order.triggered) {
-		return ZERO;
-	}
-
-	return calculateAmountToTradeForLimit(market, order);
-}
-
-function isSameDirection(
-	firstDirection: PositionDirection,
-	secondDirection: PositionDirection
-): boolean {
-	return (
-		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
-		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
-	);
-}
-
-function calculateAmountToTradeForTriggerMarket(
-	market: MarketAccount,
-	order: Order
-): BN {
-	if (!order.triggered) {
-		return ZERO;
-	}
-
-	return order.baseAssetAmount;
-}

package/src/slot/SlotSubscriber.js

@@ -1,39 +0,0 @@
-"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/tokenFaucet.js

@@ -1,189 +0,0 @@
-"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/types.js

@@ -1,125 +0,0 @@
-"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/userName.js

@@ -1,20 +0,0 @@
-"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;

package/src/wallet.js

@@ -1,35 +0,0 @@
-"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.Wallet = void 0;
-class Wallet {
-    constructor(payer) {
-        this.payer = payer;
-    }
-    signTransaction(tx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            tx.partialSign(this.payer);
-            return tx;
-        });
-    }
-    signAllTransactions(txs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return txs.map((t) => {
-                t.partialSign(this.payer);
-                return t;
-            });
-        });
-    }
-    get publicKey() {
-        return this.payer.publicKey;
-    }
-}
-exports.Wallet = Wallet;