@drift-labs/sdk 0.2.0-master.8 → 0.2.0-temp.1

package/src/clearingHouse.ts

@@ -29,7 +29,7 @@ import {
 	AccountMeta,
 } from '@solana/web3.js';
 
-import { MockUSDCFaucet } from './mockUSDCFaucet';
+import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
@@ -644,11 +644,12 @@ export class ClearingHouse {
 	public async initializeUserAccountForDevnet(
 		userId = 0,
 		name = DEFAULT_USER_NAME,
-		mockUSDCFaucet: MockUSDCFaucet,
+		bankIndex: BN,
+		tokenFaucet: TokenFaucet,
 		amount: BN
 	): Promise<[TransactionSignature, PublicKey]> {
 		const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] =
-			await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(
+			await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(
 				this.wallet.publicKey,
 				amount
 			);
@@ -658,7 +659,7 @@ export class ClearingHouse {
 
 		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
-			new BN(0),
+			bankIndex,
 			associateTokenPublicKey,
 			userId,
 			false,
@@ -1390,72 +1391,359 @@ export class ClearingHouse {
 		});
 	}
 
-	public async liquidate(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async liquidatePerp(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN,
+		maxBaseAssetAmount: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getLiquidateIx(liquidateeUserAccountPublicKey)),
+			wrapInTx(
+				await this.getLiquidatePerpIx(
+					userAccountPublicKey,
+					userAccount,
+					marketIndex,
+					maxBaseAssetAmount
+				)
+			),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getLiquidateIx(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async getLiquidatePerpIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN,
+		maxBaseAssetAmount: BN
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const liquidateeUserAccount = (await this.program.account.user.fetch(
-			liquidateeUserAccountPublicKey
-		)) as UserAccount;
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+			writableMarketIndex: marketIndex,
+			userAccount,
+		});
 
-		const bankAccountInfos = [
+		return await this.program.instruction.liquidatePerp(
+			marketIndex,
+			maxBaseAssetAmount,
 			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
-			},
-		];
-		const marketAccountInfos = [];
-		const oracleAccountInfos = [];
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidateBorrow(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetBankIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidateBorrowIx(
+					userAccountPublicKey,
+					userAccount,
+					assetBankIndex,
+					liabilityBankIndex,
+					maxLiabilityTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidateBorrowIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetBankIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+			userAccount,
+			writableBankIndexes: [liabilityBankIndex, assetBankIndex],
+		});
+
+		return await this.program.instruction.liquidateBorrow(
+			assetBankIndex,
+			liabilityBankIndex,
+			maxLiabilityTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidateBorrowForPerpPnl(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidateBorrowForPerpPnlIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					liabilityBankIndex,
+					maxLiabilityTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidateBorrowForPerpPnlIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+			userAccount,
+			writableMarketIndex: perpMarketIndex,
+			writableBankIndexes: [liabilityBankIndex],
+		});
+
+		return await this.program.instruction.liquidateBorrowForPerpPnl(
+			perpMarketIndex,
+			liabilityBankIndex,
+			maxLiabilityTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidatePerpPnlForDeposit(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		assetBankIndex: BN,
+		maxPnlTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidatePerpPnlForDepositIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					assetBankIndex,
+					maxPnlTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidatePerpPnlForDepositIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		assetBankIndex: BN,
+		maxPnlTransfer: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+			userAccount,
+			writableMarketIndex: perpMarketIndex,
+			writableBankIndexes: [assetBankIndex],
+		});
+
+		return await this.program.instruction.liquidatePerpPnlForDeposit(
+			perpMarketIndex,
+			assetBankIndex,
+			maxPnlTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	getRemainingAccountsForLiquidation(params: {
+		userAccount: UserAccount;
+		writableMarketIndex?: BN;
+		writableBankIndexes?: BN[];
+	}): AccountMeta[] {
+		const liquidateeUserAccount = params.userAccount;
+
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
+		for (const bankBalance of liquidateeUserAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
 		for (const position of liquidateeUserAccount.positions) {
 			if (!positionIsAvailable(position)) {
 				const market = this.getMarketAccount(position.marketIndex);
-				const marketPublicKey = await getMarketPublicKey(
-					this.program.programId,
-					position.marketIndex
-				);
-				marketAccountInfos.push({
-					pubkey: marketPublicKey,
-					isWritable: true,
+				marketAccountMap.set(position.marketIndex.toNumber(), {
+					pubkey: market.pubkey,
+					isWritable: false,
 					isSigner: false,
 				});
-				oracleAccountInfos.push({
+				oracleAccountMap.set(market.amm.oracle.toString(), {
 					pubkey: market.amm.oracle,
 					isWritable: false,
 					isSigner: false,
 				});
 			}
 		}
-		const remainingAccounts = oracleAccountInfos.concat(
-			bankAccountInfos.concat(marketAccountInfos)
-		);
 
-		const state = this.getStateAccount();
-		const quoteAssetBankAccount = this.getQuoteAssetBankAccount();
-		return await this.program.instruction.liquidate({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				authority: this.wallet.publicKey,
-				user: liquidateeUserAccountPublicKey,
-				liquidator: userAccountPublicKey,
-				bankVault: quoteAssetBankAccount.vault,
-				bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
-				insuranceVault: state.insuranceVault,
-				tokenProgram: TOKEN_PROGRAM_ID,
-			},
-			remainingAccounts: remainingAccounts,
-		});
+		const userAccountAndSlot = this.getUserAccountAndSlot();
+		if (!userAccountAndSlot) {
+			throw Error(
+				'No user account found. Most likely user account does not exist or failed to fetch account'
+			);
+		}
+		const { data: userAccount, slot: lastUserPositionsSlot } =
+			userAccountAndSlot;
+
+		for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
+			// if cache has more recent slot than user positions account slot, add market to remaining accounts
+			// otherwise remove from slot
+			if (slot > lastUserPositionsSlot) {
+				const marketAccount = this.getMarketAccount(marketIndexNum);
+				marketAccountMap.set(marketIndexNum, {
+					pubkey: marketAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+				oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+					pubkey: marketAccount.amm.oracle,
+					isSigner: false,
+					isWritable: false,
+				});
+			} else {
+				this.marketLastSlotCache.delete(marketIndexNum);
+			}
+		}
+		for (const bankBalance of userAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+		for (const position of userAccount.positions) {
+			if (!positionIsAvailable(position)) {
+				const market = this.getMarketAccount(position.marketIndex);
+				marketAccountMap.set(position.marketIndex.toNumber(), {
+					pubkey: market.pubkey,
+					isWritable: false,
+					isSigner: false,
+				});
+				oracleAccountMap.set(market.amm.oracle.toString(), {
+					pubkey: market.amm.oracle,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
+		}
+
+		if (params.writableMarketIndex) {
+			const market = this.getMarketAccount(params.writableMarketIndex);
+			marketAccountMap.set(market.marketIndex.toNumber(), {
+				pubkey: market.pubkey,
+				isSigner: false,
+				isWritable: true,
+			});
+			oracleAccountMap.set(market.amm.oracle.toString(), {
+				pubkey: market.amm.oracle,
+				isSigner: false,
+				isWritable: false,
+			});
+		}
+
+		if (params.writableBankIndexes) {
+			for (const writableBankIndex of params.writableBankIndexes) {
+				const bank = this.getBankAccount(writableBankIndex);
+				bankAccountMap.set(bank.bankIndex.toNumber(), {
+					pubkey: bank.pubkey,
+					isSigner: false,
+					isWritable: true,
+				});
+				if (!bank.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bank.oracle.toString(), {
+						pubkey: bank.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
+		return [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
 	}
 
 	public async updateFundingRate(

package/src/clearingHouseConfig.js

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

package/src/clearingHouseUser.ts

@@ -205,7 +205,7 @@ export class ClearingHouseUser {
 	/**
 	 * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getPartialMarginRequirement(): BN {
+	public getMaintenanceMarginRequirement(): BN {
 		return this.getUserAccount()
 			.positions.reduce((marginRequirement, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
@@ -217,7 +217,7 @@ export class ClearingHouseUser {
 						marketPosition,
 						this.getOracleDataForMarket(market.marketIndex)
 					)
-						.mul(new BN(market.marginRatioPartial))
+						.mul(new BN(market.marginRatioMaintenance))
 						.div(MARGIN_PRECISION)
 				);
 			}, ZERO)
@@ -514,9 +514,6 @@ export class ClearingHouseUser {
 			case 'Maintenance':
 				marginRatioCategory = market.marginRatioMaintenance;
 				break;
-			case 'Partial':
-				marginRatioCategory = market.marginRatioPartial;
-				break;
 			default:
 				marginRatioCategory = market.marginRatioInitial;
 				break;
@@ -543,7 +540,8 @@ export class ClearingHouseUser {
 
 	public canBeLiquidated(): [boolean, BN] {
 		const totalCollateral = this.getTotalCollateral();
-		const partialMaintenanceRequirement = this.getPartialMarginRequirement();
+		const partialMaintenanceRequirement =
+			this.getMaintenanceMarginRequirement();
 		const marginRatio = this.getMarginRatio();
 		const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
 		return [canLiquidate, marginRatio];
@@ -587,8 +585,7 @@ export class ClearingHouseUser {
 	 */
 	public liquidationPrice(
 		marketPosition: Pick<UserPosition, 'marketIndex'>,
-		positionBaseSizeChange: BN = ZERO,
-		partial = false
+		positionBaseSizeChange: BN = ZERO
 	): BN {
 		// solves formula for example canBeLiquidated below
 
@@ -661,11 +658,7 @@ export class ClearingHouseUser {
 							this.getOracleDataForMarket(market.marketIndex)
 						);
 						const marketMarginRequirement = positionValue
-							.mul(
-								partial
-									? new BN(market.marginRatioPartial)
-									: new BN(market.marginRatioMaintenance)
-							)
+							.mul(new BN(market.marginRatioMaintenance))
 							.div(MARGIN_PRECISION);
 						totalMarginRequirement = totalMarginRequirement.add(
 							marketMarginRequirement
@@ -691,20 +684,17 @@ export class ClearingHouseUser {
 		const marginRequirementAfterTrade =
 			marginRequirementExcludingTargetMarket.add(
 				proposedMarketPositionValue
-					.mul(
-						partial
-							? new BN(market.marginRatioPartial)
-							: new BN(market.marginRatioMaintenance)
-					)
+					.mul(new BN(market.marginRatioMaintenance))
 					.div(MARGIN_PRECISION)
 			);
 		const freeCollateralAfterTrade = totalCollateral.sub(
 			marginRequirementAfterTrade
 		);
 
-		const marketMaxLeverage = partial
-			? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-			: this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+		const marketMaxLeverage = this.getMaxLeverage(
+			proposedMarketPosition.marketIndex,
+			'Maintenance'
+		);
 
 		let priceDelta;
 		if (proposedBaseAssetAmount.lt(ZERO)) {
@@ -777,8 +767,7 @@ export class ClearingHouseUser {
 			{
 				marketIndex: positionMarketIndex,
 			},
-			closeBaseAmount,
-			true
+			closeBaseAmount
 		);
 	}
 

package/src/clearingHouseUserConfig.js

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

package/src/config.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketsBanksAndOraclesForSubscription = exports.initialize = exports.getConfig = exports.configs = void 0;
+const markets_1 = require("./constants/markets");
+const banks_1 = require("./constants/banks");
+exports.configs = {
+    devnet: {
+        ENV: 'devnet',
+        PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
+        CLEARING_HOUSE_PROGRAM_ID: '4oyTJnAQ9FqJj1y9mPytbWsLeeHmBzGYfuFqypwyQvuh',
+        USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
+        MARKETS: markets_1.DevnetMarkets,
+        BANKS: banks_1.DevnetBanks,
+    },
+    'mainnet-beta': {
+        ENV: 'mainnet-beta',
+        PYTH_ORACLE_MAPPING_ADDRESS: 'AHtgzX45WTKfkPG53L6WYhGEXwQkN1BVknET3sVsLL8J',
+        CLEARING_HOUSE_PROGRAM_ID: 'dammHkt7jmytvbS3nHTxQNEcP59aE57nxwV21YdqEDN',
+        USDC_MINT_ADDRESS: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+        MARKETS: markets_1.MainnetMarkets,
+        BANKS: banks_1.MainnetBanks,
+    },
+};
+let currentConfig = exports.configs.devnet;
+const getConfig = () => currentConfig;
+exports.getConfig = getConfig;
+/**
+ * Allows customization of the SDK's environment and endpoints. You can pass individual settings to override the settings with your own presets.
+ *
+ * Defaults to master environment if you don't use this function.
+ * @param props
+ * @returns
+ */
+const initialize = (props) => {
+    var _a, _b;
+    //@ts-ignore
+    if (props.env === 'master')
+        return Object.assign(Object.assign({}, exports.configs['devnet']), ((_a = props.overrideEnv) !== null && _a !== void 0 ? _a : {}));
+    currentConfig = Object.assign(Object.assign({}, exports.configs[props.env]), ((_b = props.overrideEnv) !== null && _b !== void 0 ? _b : {}));
+    return currentConfig;
+};
+exports.initialize = initialize;
+function getMarketsBanksAndOraclesForSubscription(env) {
+    const marketIndexes = [];
+    const bankIndexes = [];
+    const oracleInfos = new Map();
+    for (const market of markets_1.Markets[env]) {
+        marketIndexes.push(market.marketIndex);
+        oracleInfos.set(market.oracle.toString(), {
+            publicKey: market.oracle,
+            source: market.oracleSource,
+        });
+    }
+    for (const bank of banks_1.Banks[env]) {
+        bankIndexes.push(bank.bankIndex);
+        oracleInfos.set(bank.oracle.toString(), {
+            publicKey: bank.oracle,
+            source: bank.oracleSource,
+        });
+    }
+    return {
+        marketIndexes,
+        bankIndexes,
+        oracleInfos: Array.from(oracleInfos.values()),
+    };
+}
+exports.getMarketsBanksAndOraclesForSubscription = getMarketsBanksAndOraclesForSubscription;

package/src/config.ts

@@ -28,7 +28,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: 'BMow898PH56jD8z4EaqxicoGXkR1HhN17qrER6Uc4AYq',
+		CLEARING_HOUSE_PROGRAM_ID: '4oyTJnAQ9FqJj1y9mPytbWsLeeHmBzGYfuFqypwyQvuh',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
 		MARKETS: DevnetMarkets,
 		BANKS: DevnetBanks,

package/src/constants/banks.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Banks = exports.MainnetBanks = exports.DevnetBanks = exports.WRAPPED_SOL_MINT = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const __1 = require("../");
+exports.WRAPPED_SOL_MINT = new web3_js_1.PublicKey('So11111111111111111111111111111111111111112');
+exports.DevnetBanks = [
+    {
+        symbol: 'USDC',
+        bankIndex: new __1.BN(0),
+        oracle: web3_js_1.PublicKey.default,
+        oracleSource: __1.OracleSource.QUOTE_ASSET,
+        mint: new web3_js_1.PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
+    },
+    {
+        symbol: 'SOL',
+        bankIndex: new __1.BN(1),
+        oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey(exports.WRAPPED_SOL_MINT),
+    },
+    {
+        symbol: 'BTC',
+        bankIndex: new __1.BN(2),
+        oracle: new web3_js_1.PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey('3BZPwbcqB5kKScF3TEXxwNfx5ipV13kbRVDvfVp5c6fv'),
+    },
+];
+exports.MainnetBanks = [
+    {
+        symbol: 'USDC',
+        bankIndex: new __1.BN(0),
+        oracle: web3_js_1.PublicKey.default,
+        oracleSource: __1.OracleSource.QUOTE_ASSET,
+        mint: new web3_js_1.PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
+    },
+];
+exports.Banks = {
+    devnet: exports.DevnetBanks,
+    'mainnet-beta': exports.MainnetBanks,
+};

package/src/constants/banks.ts

@@ -1,7 +1,6 @@
 import { BN, OracleSource } from '../';
 import { DriftEnv } from '../';
 import { PublicKey } from '@solana/web3.js';
-import { WRAPPED_SOL_MINT } from '@project-serum/serum/lib/token-instructions';
 
 export type BankConfig = {
 	symbol: string;
@@ -24,14 +23,14 @@ export const DevnetBanks: BankConfig[] = [
 		bankIndex: new BN(1),
 		oracle: new PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
 		oracleSource: OracleSource.PYTH,
-		mint: WRAPPED_SOL_MINT,
+		mint: new PublicKey('So11111111111111111111111111111111111111112'),
 	},
 	{
 		symbol: 'BTC',
 		bankIndex: new BN(2),
 		oracle: new PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
 		oracleSource: OracleSource.PYTH,
-		mint: new PublicKey('Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr'),
+		mint: new PublicKey('3BZPwbcqB5kKScF3TEXxwNfx5ipV13kbRVDvfVp5c6fv'),
 	},
 ];