2022-06-24 07:41:04 -07:00
|
|
|
import { Jupiter } from '@jup-ag/core';
|
2022-05-18 08:16:14 -07:00
|
|
|
import { AnchorProvider, BN, Program, Provider } from '@project-serum/anchor';
|
2022-06-11 04:49:45 -07:00
|
|
|
import { getFeeRates, getFeeTier } from '@project-serum/serum';
|
2022-04-08 07:57:37 -07:00
|
|
|
import { Order } from '@project-serum/serum/lib/market';
|
2022-05-25 17:29:06 -07:00
|
|
|
import {
|
|
|
|
closeAccount,
|
|
|
|
initializeAccount,
|
|
|
|
WRAPPED_SOL_MINT,
|
|
|
|
} from '@project-serum/serum/lib/token-instructions';
|
2022-06-23 03:58:43 -07:00
|
|
|
import {
|
|
|
|
ASSOCIATED_TOKEN_PROGRAM_ID,
|
2022-06-24 07:41:04 -07:00
|
|
|
Token,
|
2022-06-23 03:58:43 -07:00
|
|
|
TOKEN_PROGRAM_ID,
|
|
|
|
} from '@solana/spl-token';
|
2022-04-07 09:58:42 -07:00
|
|
|
import {
|
2022-04-07 12:00:08 -07:00
|
|
|
AccountMeta,
|
2022-06-11 04:49:45 -07:00
|
|
|
Cluster,
|
2022-05-11 04:33:01 -07:00
|
|
|
Keypair,
|
2022-06-01 01:10:43 -07:00
|
|
|
LAMPORTS_PER_SOL,
|
2022-04-08 03:30:21 -07:00
|
|
|
MemcmpFilter,
|
2022-04-07 12:00:08 -07:00
|
|
|
PublicKey,
|
2022-06-01 01:10:43 -07:00
|
|
|
Signer,
|
2022-05-11 04:33:01 -07:00
|
|
|
SystemProgram,
|
2022-07-06 21:45:01 -07:00
|
|
|
SYSVAR_INSTRUCTIONS_PUBKEY,
|
2022-04-07 12:00:08 -07:00
|
|
|
SYSVAR_RENT_PUBKEY,
|
2022-06-24 07:41:04 -07:00
|
|
|
Transaction,
|
2022-05-25 17:29:06 -07:00
|
|
|
TransactionInstruction,
|
2022-06-01 01:10:43 -07:00
|
|
|
TransactionSignature,
|
2022-04-07 12:00:08 -07:00
|
|
|
} from '@solana/web3.js';
|
2022-04-07 23:29:35 -07:00
|
|
|
import bs58 from 'bs58';
|
2022-06-09 09:27:31 -07:00
|
|
|
import { Bank, MintInfo } from './accounts/bank';
|
2022-04-12 08:28:47 -07:00
|
|
|
import { Group } from './accounts/group';
|
|
|
|
import { I80F48 } from './accounts/I80F48';
|
2022-07-04 03:29:35 -07:00
|
|
|
import { MangoAccount, MangoAccountData } from './accounts/mangoAccount';
|
2022-04-12 08:28:47 -07:00
|
|
|
import { StubOracle } from './accounts/oracle';
|
2022-05-11 04:33:01 -07:00
|
|
|
import { OrderType, PerpMarket, Side } from './accounts/perp';
|
2022-04-08 03:30:21 -07:00
|
|
|
import {
|
|
|
|
Serum3Market,
|
|
|
|
Serum3OrderType,
|
|
|
|
Serum3SelfTradeBehavior,
|
|
|
|
Serum3Side,
|
2022-04-12 08:28:47 -07:00
|
|
|
} from './accounts/serum3';
|
2022-06-11 04:49:45 -07:00
|
|
|
import { SERUM3_PROGRAM_ID } from './constants';
|
2022-06-21 11:04:21 -07:00
|
|
|
import { Id } from './ids';
|
2022-06-01 01:10:43 -07:00
|
|
|
import { IDL, MangoV4 } from './mango_v4';
|
2022-06-23 01:19:33 -07:00
|
|
|
import { FlashLoanWithdraw } from './types';
|
2022-06-02 10:30:39 -07:00
|
|
|
import {
|
|
|
|
getAssociatedTokenAddress,
|
|
|
|
I64_MAX_BN,
|
|
|
|
toNativeDecimals,
|
|
|
|
toU64,
|
|
|
|
} from './utils';
|
2022-02-23 02:09:17 -08:00
|
|
|
|
2022-07-04 03:09:33 -07:00
|
|
|
// TODO: replace ui values with native as input wherever possible
|
|
|
|
// TODO: replace token/market names with token or market indices
|
2022-02-23 02:09:17 -08:00
|
|
|
export class MangoClient {
|
2022-06-11 04:49:45 -07:00
|
|
|
constructor(
|
|
|
|
public program: Program<MangoV4>,
|
|
|
|
public programId: PublicKey,
|
|
|
|
public cluster: Cluster,
|
2022-06-21 11:04:21 -07:00
|
|
|
public groupName?: string,
|
2022-06-11 04:49:45 -07:00
|
|
|
) {}
|
2022-02-23 02:09:17 -08:00
|
|
|
|
2022-04-07 09:58:42 -07:00
|
|
|
/// public
|
|
|
|
|
2022-04-07 10:42:00 -07:00
|
|
|
// Group
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async createGroup(
|
|
|
|
groupNum: number,
|
|
|
|
testing: boolean,
|
|
|
|
): Promise<TransactionSignature> {
|
2022-05-18 08:16:14 -07:00
|
|
|
const adminPk = (this.program.provider as AnchorProvider).wallet.publicKey;
|
2022-04-07 12:00:08 -07:00
|
|
|
return await this.program.methods
|
2022-06-09 09:27:31 -07:00
|
|
|
.createGroup(groupNum, testing ? 1 : 0)
|
2022-04-07 12:00:08 -07:00
|
|
|
.accounts({
|
|
|
|
admin: adminPk,
|
|
|
|
payer: adminPk,
|
|
|
|
})
|
|
|
|
.rpc();
|
2022-04-07 10:42:00 -07:00
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async closeGroup(group: Group): Promise<TransactionSignature> {
|
|
|
|
const adminPk = (this.program.provider as AnchorProvider).wallet.publicKey;
|
|
|
|
return await this.program.methods
|
|
|
|
.closeGroup()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
admin: adminPk,
|
|
|
|
solDestination: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-04-08 11:47:12 -07:00
|
|
|
public async getGroup(groupPk: PublicKey): Promise<Group> {
|
2022-05-02 09:26:25 -07:00
|
|
|
const groupAccount = await this.program.account.group.fetch(groupPk);
|
|
|
|
const group = Group.from(groupPk, groupAccount);
|
2022-06-11 04:49:45 -07:00
|
|
|
await group.reloadAll(this);
|
2022-04-08 11:47:12 -07:00
|
|
|
return group;
|
|
|
|
}
|
|
|
|
|
2022-05-27 05:43:53 -07:00
|
|
|
public async getGroupForAdmin(
|
|
|
|
adminPk: PublicKey,
|
|
|
|
groupNum?: number,
|
|
|
|
): Promise<Group> {
|
|
|
|
const filters: MemcmpFilter[] = [
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: adminPk.toBase58(),
|
|
|
|
offset: 8,
|
2022-04-07 12:00:08 -07:00
|
|
|
},
|
2022-05-27 05:43:53 -07:00
|
|
|
},
|
|
|
|
];
|
|
|
|
|
|
|
|
if (groupNum) {
|
|
|
|
const bbuf = Buffer.alloc(4);
|
|
|
|
bbuf.writeUInt32LE(groupNum);
|
|
|
|
filters.push({
|
|
|
|
memcmp: {
|
|
|
|
bytes: bs58.encode(bbuf),
|
|
|
|
offset: 44,
|
|
|
|
},
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const groups = (await this.program.account.group.all(filters)).map(
|
|
|
|
(tuple) => Group.from(tuple.publicKey, tuple.account),
|
|
|
|
);
|
2022-06-11 04:49:45 -07:00
|
|
|
await groups[0].reloadAll(this);
|
2022-04-07 12:00:08 -07:00
|
|
|
return groups[0];
|
2022-04-07 09:58:42 -07:00
|
|
|
}
|
|
|
|
|
2022-04-07 10:42:00 -07:00
|
|
|
// Tokens/Banks
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async tokenRegister(
|
2022-04-07 10:42:00 -07:00
|
|
|
group: Group,
|
|
|
|
mintPk: PublicKey,
|
|
|
|
oraclePk: PublicKey,
|
2022-06-18 07:38:46 -07:00
|
|
|
oracleConfFilter: number,
|
2022-04-07 10:42:00 -07:00
|
|
|
tokenIndex: number,
|
2022-04-12 07:19:58 -07:00
|
|
|
name: string,
|
2022-04-09 08:09:06 -07:00
|
|
|
util0: number,
|
|
|
|
rate0: number,
|
|
|
|
util1: number,
|
|
|
|
rate1: number,
|
|
|
|
maxRate: number,
|
2022-05-09 23:03:46 -07:00
|
|
|
loanFeeRate: number,
|
|
|
|
loanOriginationFeeRate: number,
|
2022-04-09 08:09:06 -07:00
|
|
|
maintAssetWeight: number,
|
|
|
|
initAssetWeight: number,
|
|
|
|
maintLiabWeight: number,
|
|
|
|
initLiabWeight: number,
|
|
|
|
liquidationFee: number,
|
2022-04-07 10:42:00 -07:00
|
|
|
): Promise<TransactionSignature> {
|
2022-06-18 07:38:46 -07:00
|
|
|
const bn = I80F48.fromNumber(oracleConfFilter).getData();
|
2022-04-07 12:00:08 -07:00
|
|
|
return await this.program.methods
|
2022-06-09 09:27:31 -07:00
|
|
|
.tokenRegister(
|
2022-04-07 12:00:08 -07:00
|
|
|
tokenIndex,
|
2022-06-27 02:27:17 -07:00
|
|
|
new BN(0),
|
2022-04-12 07:19:58 -07:00
|
|
|
name,
|
2022-06-18 07:38:46 -07:00
|
|
|
{
|
|
|
|
confFilter: {
|
|
|
|
val: I80F48.fromNumber(oracleConfFilter).getData(),
|
|
|
|
},
|
|
|
|
} as any, // future: nested custom types dont typecheck, fix if possible?
|
2022-04-12 07:53:45 -07:00
|
|
|
{ util0, rate0, util1, rate1, maxRate },
|
2022-05-09 23:03:46 -07:00
|
|
|
loanFeeRate,
|
|
|
|
loanOriginationFeeRate,
|
2022-04-09 08:09:06 -07:00
|
|
|
maintAssetWeight,
|
|
|
|
initAssetWeight,
|
|
|
|
maintLiabWeight,
|
|
|
|
initLiabWeight,
|
|
|
|
liquidationFee,
|
2022-04-07 12:00:08 -07:00
|
|
|
)
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
admin: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 12:00:08 -07:00
|
|
|
mint: mintPk,
|
|
|
|
oracle: oraclePk,
|
2022-05-18 08:16:14 -07:00
|
|
|
payer: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 12:00:08 -07:00
|
|
|
rent: SYSVAR_RENT_PUBKEY,
|
|
|
|
})
|
|
|
|
.rpc();
|
2022-04-07 10:42:00 -07:00
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async tokenDeregister(
|
|
|
|
group: Group,
|
|
|
|
tokenName: string,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
const bank = group.banksMap.get(tokenName)!;
|
|
|
|
const adminPk = (this.program.provider as AnchorProvider).wallet.publicKey;
|
2022-06-29 00:11:14 -07:00
|
|
|
|
|
|
|
const dustVaultPk = await getAssociatedTokenAddress(bank.mint, adminPk);
|
|
|
|
const ai = await this.program.provider.connection.getAccountInfo(
|
|
|
|
dustVaultPk,
|
|
|
|
);
|
|
|
|
if (!ai) {
|
|
|
|
const tx = new Transaction();
|
|
|
|
tx.add(
|
|
|
|
Token.createAssociatedTokenAccountInstruction(
|
|
|
|
ASSOCIATED_TOKEN_PROGRAM_ID,
|
|
|
|
TOKEN_PROGRAM_ID,
|
|
|
|
bank.mint,
|
|
|
|
dustVaultPk,
|
|
|
|
adminPk,
|
|
|
|
adminPk,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
await this.program.provider.sendAndConfirm(tx);
|
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
return await this.program.methods
|
2022-06-27 02:27:17 -07:00
|
|
|
.tokenDeregister(bank.tokenIndex)
|
2022-06-09 09:27:31 -07:00
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
admin: adminPk,
|
2022-06-11 04:49:45 -07:00
|
|
|
mintInfo: group.mintInfosMap.get(bank.tokenIndex)?.publicKey,
|
2022-06-29 00:11:14 -07:00
|
|
|
dustVault: dustVaultPk,
|
2022-06-09 09:27:31 -07:00
|
|
|
solDestination: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
|
|
|
})
|
2022-06-27 02:27:17 -07:00
|
|
|
.remainingAccounts(
|
|
|
|
[bank.publicKey, bank.vault].map(
|
|
|
|
(pk) =>
|
|
|
|
({ pubkey: pk, isWritable: true, isSigner: false } as AccountMeta),
|
|
|
|
),
|
|
|
|
)
|
2022-06-09 09:27:31 -07:00
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-04-07 09:58:42 -07:00
|
|
|
public async getBanksForGroup(group: Group): Promise<Bank[]> {
|
2022-04-07 12:00:08 -07:00
|
|
|
return (
|
|
|
|
await this.program.account.bank.all([
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: group.publicKey.toBase58(),
|
2022-04-12 07:19:58 -07:00
|
|
|
offset: 24,
|
2022-04-07 12:00:08 -07:00
|
|
|
},
|
|
|
|
},
|
|
|
|
])
|
|
|
|
).map((tuple) => Bank.from(tuple.publicKey, tuple.account));
|
2022-04-07 09:58:42 -07:00
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async getMintInfosForGroup(group: Group): Promise<MintInfo[]> {
|
|
|
|
return (
|
|
|
|
await this.program.account.mintInfo.all([
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: group.publicKey.toBase58(),
|
|
|
|
offset: 8,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
])
|
|
|
|
).map((tuple) => {
|
|
|
|
return MintInfo.from(tuple.publicKey, tuple.account);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
public async getMintInfoForTokenIndex(
|
|
|
|
group: Group,
|
|
|
|
tokenIndex: number,
|
|
|
|
): Promise<MintInfo[]> {
|
|
|
|
const tokenIndexBuf = Buffer.alloc(2);
|
|
|
|
tokenIndexBuf.writeUInt16LE(tokenIndex);
|
|
|
|
return (
|
|
|
|
await this.program.account.mintInfo.all([
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: group.publicKey.toBase58(),
|
|
|
|
offset: 8,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: bs58.encode(tokenIndexBuf),
|
|
|
|
offset: 200,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
])
|
|
|
|
).map((tuple) => {
|
|
|
|
return MintInfo.from(tuple.publicKey, tuple.account);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-04-07 11:05:06 -07:00
|
|
|
// Stub Oracle
|
|
|
|
|
2022-04-07 10:42:00 -07:00
|
|
|
public async createStubOracle(
|
|
|
|
group: Group,
|
|
|
|
mintPk: PublicKey,
|
|
|
|
price: number,
|
|
|
|
): Promise<TransactionSignature> {
|
2022-04-07 12:00:08 -07:00
|
|
|
return await this.program.methods
|
|
|
|
.createStubOracle({ val: I80F48.fromNumber(price).getData() })
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
admin: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 12:00:08 -07:00
|
|
|
tokenMint: mintPk,
|
2022-05-18 08:16:14 -07:00
|
|
|
payer: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 12:00:08 -07:00
|
|
|
})
|
|
|
|
.rpc();
|
2022-04-07 10:42:00 -07:00
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async closeStubOracle(
|
|
|
|
group: Group,
|
|
|
|
oracle: PublicKey,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
return await this.program.methods
|
|
|
|
.closeStubOracle()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
oracle: oracle,
|
|
|
|
solDestination: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-04-07 10:42:00 -07:00
|
|
|
public async setStubOracle(
|
|
|
|
group: Group,
|
2022-06-18 07:31:28 -07:00
|
|
|
oraclePk: PublicKey,
|
2022-04-07 10:42:00 -07:00
|
|
|
price: number,
|
|
|
|
): Promise<TransactionSignature> {
|
2022-04-07 12:00:08 -07:00
|
|
|
return await this.program.methods
|
|
|
|
.setStubOracle({ val: I80F48.fromNumber(price).getData() })
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
admin: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-06-18 07:31:28 -07:00
|
|
|
oracle: oraclePk,
|
2022-05-18 08:16:14 -07:00
|
|
|
payer: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 12:00:08 -07:00
|
|
|
})
|
|
|
|
.rpc();
|
2022-04-07 10:42:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
public async getStubOracle(
|
|
|
|
group: Group,
|
2022-06-11 04:49:45 -07:00
|
|
|
mintPk?: PublicKey,
|
|
|
|
): Promise<StubOracle[]> {
|
|
|
|
const filters = [
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: group.publicKey.toBase58(),
|
|
|
|
offset: 8,
|
2022-04-07 12:00:08 -07:00
|
|
|
},
|
2022-06-11 04:49:45 -07:00
|
|
|
},
|
|
|
|
];
|
|
|
|
|
|
|
|
if (mintPk) {
|
|
|
|
filters.push({
|
|
|
|
memcmp: {
|
|
|
|
bytes: mintPk.toBase58(),
|
|
|
|
offset: 40,
|
2022-04-07 12:00:08 -07:00
|
|
|
},
|
2022-06-11 04:49:45 -07:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return (await this.program.account.stubOracle.all(filters)).map((pa) =>
|
|
|
|
StubOracle.from(pa.publicKey, pa.account),
|
|
|
|
);
|
2022-04-07 10:42:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// MangoAccount
|
|
|
|
|
2022-04-08 03:30:21 -07:00
|
|
|
public async getOrCreateMangoAccount(
|
|
|
|
group: Group,
|
|
|
|
ownerPk: PublicKey,
|
|
|
|
accountNumber?: number,
|
2022-04-12 07:19:58 -07:00
|
|
|
name?: string,
|
2022-04-08 03:30:21 -07:00
|
|
|
): Promise<MangoAccount> {
|
|
|
|
let mangoAccounts = await this.getMangoAccountForOwner(group, ownerPk);
|
|
|
|
if (mangoAccounts.length === 0) {
|
2022-04-12 07:19:58 -07:00
|
|
|
await this.createMangoAccount(group, accountNumber ?? 0, name ?? '');
|
2022-04-08 11:47:12 -07:00
|
|
|
mangoAccounts = await this.getMangoAccountForOwner(group, ownerPk);
|
2022-04-08 03:30:21 -07:00
|
|
|
}
|
|
|
|
return mangoAccounts[0];
|
|
|
|
}
|
|
|
|
|
2022-04-07 09:58:42 -07:00
|
|
|
public async createMangoAccount(
|
|
|
|
group: Group,
|
|
|
|
accountNumber: number,
|
2022-04-12 07:19:58 -07:00
|
|
|
name?: string,
|
2022-04-07 09:58:42 -07:00
|
|
|
): Promise<TransactionSignature> {
|
2022-04-07 12:00:08 -07:00
|
|
|
return await this.program.methods
|
2022-04-12 07:19:58 -07:00
|
|
|
.createAccount(accountNumber, name ?? '')
|
2022-04-07 12:00:08 -07:00
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
|
|
|
payer: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 12:00:08 -07:00
|
|
|
})
|
|
|
|
.rpc();
|
2022-04-07 09:58:42 -07:00
|
|
|
}
|
|
|
|
|
2022-04-08 03:30:21 -07:00
|
|
|
public async getMangoAccount(mangoAccount: MangoAccount) {
|
|
|
|
return MangoAccount.from(
|
|
|
|
mangoAccount.publicKey,
|
|
|
|
await this.program.account.mangoAccount.fetch(mangoAccount.publicKey),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
public async getMangoAccountForOwner(
|
2022-04-07 09:58:42 -07:00
|
|
|
group: Group,
|
|
|
|
ownerPk: PublicKey,
|
|
|
|
): Promise<MangoAccount[]> {
|
2022-04-07 12:00:08 -07:00
|
|
|
return (
|
|
|
|
await this.program.account.mangoAccount.all([
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: group.publicKey.toBase58(),
|
2022-04-12 23:48:35 -07:00
|
|
|
offset: 40,
|
2022-04-07 12:00:08 -07:00
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: ownerPk.toBase58(),
|
2022-04-12 23:48:35 -07:00
|
|
|
offset: 72,
|
2022-04-07 12:00:08 -07:00
|
|
|
},
|
|
|
|
},
|
|
|
|
])
|
|
|
|
).map((pa) => {
|
|
|
|
return MangoAccount.from(pa.publicKey, pa.account);
|
|
|
|
});
|
2022-04-07 09:58:42 -07:00
|
|
|
}
|
|
|
|
|
2022-04-08 08:21:49 -07:00
|
|
|
public async closeMangoAccount(
|
2022-07-04 03:09:33 -07:00
|
|
|
group: Group,
|
2022-04-08 08:21:49 -07:00
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
return await this.program.methods
|
|
|
|
.closeAccount()
|
|
|
|
.accounts({
|
2022-07-04 03:09:33 -07:00
|
|
|
group: group.publicKey,
|
2022-04-08 08:21:49 -07:00
|
|
|
account: mangoAccount.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-06-09 09:27:31 -07:00
|
|
|
solDestination: mangoAccount.owner,
|
2022-04-08 08:21:49 -07:00
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-07-04 03:29:35 -07:00
|
|
|
public async computeAccountData(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
): Promise<MangoAccountData> {
|
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount);
|
|
|
|
|
|
|
|
const res = await this.program.methods
|
|
|
|
.computeAccountData()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
})
|
|
|
|
.remainingAccounts(
|
|
|
|
healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({ pubkey: pk, isWritable: false, isSigner: false } as AccountMeta),
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.simulate();
|
|
|
|
|
|
|
|
return MangoAccountData.from(
|
|
|
|
res.events.find((event) => (event.name = 'MangoAccountData')).data as any,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async tokenDeposit(
|
2022-04-07 09:58:42 -07:00
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
2022-04-08 03:30:21 -07:00
|
|
|
tokenName: string,
|
2022-04-07 09:58:42 -07:00
|
|
|
amount: number,
|
|
|
|
) {
|
2022-04-08 03:30:21 -07:00
|
|
|
const bank = group.banksMap.get(tokenName)!;
|
|
|
|
|
2022-05-25 17:29:06 -07:00
|
|
|
const tokenAccountPk = await getAssociatedTokenAddress(
|
2022-04-07 09:58:42 -07:00
|
|
|
bank.mint,
|
|
|
|
mangoAccount.owner,
|
|
|
|
);
|
|
|
|
|
2022-05-25 17:29:06 -07:00
|
|
|
let wrappedSolAccount: Keypair | undefined;
|
|
|
|
let preInstructions: TransactionInstruction[] = [];
|
|
|
|
let postInstructions: TransactionInstruction[] = [];
|
|
|
|
let additionalSigners: Signer[] = [];
|
|
|
|
if (bank.mint.equals(WRAPPED_SOL_MINT)) {
|
|
|
|
wrappedSolAccount = new Keypair();
|
|
|
|
const lamports = Math.round(amount * LAMPORTS_PER_SOL) + 1e7;
|
|
|
|
|
|
|
|
preInstructions = [
|
|
|
|
SystemProgram.createAccount({
|
|
|
|
fromPubkey: mangoAccount.owner,
|
|
|
|
newAccountPubkey: wrappedSolAccount.publicKey,
|
|
|
|
lamports,
|
|
|
|
space: 165,
|
|
|
|
programId: TOKEN_PROGRAM_ID,
|
|
|
|
}),
|
|
|
|
initializeAccount({
|
|
|
|
account: wrappedSolAccount.publicKey,
|
|
|
|
mint: WRAPPED_SOL_MINT,
|
|
|
|
owner: mangoAccount.owner,
|
|
|
|
}),
|
|
|
|
];
|
|
|
|
postInstructions = [
|
|
|
|
closeAccount({
|
|
|
|
source: wrappedSolAccount.publicKey,
|
|
|
|
destination: mangoAccount.owner,
|
|
|
|
owner: mangoAccount.owner,
|
|
|
|
}),
|
|
|
|
];
|
|
|
|
additionalSigners.push(wrappedSolAccount);
|
|
|
|
}
|
|
|
|
|
2022-04-07 09:58:42 -07:00
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
2022-05-31 18:38:47 -07:00
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount, [bank]);
|
2022-04-07 09:58:42 -07:00
|
|
|
|
2022-04-07 12:00:08 -07:00
|
|
|
return await this.program.methods
|
2022-06-09 09:27:31 -07:00
|
|
|
.tokenDeposit(toNativeDecimals(amount, bank.mintDecimals))
|
2022-04-07 12:00:08 -07:00
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
bank: bank.publicKey,
|
|
|
|
vault: bank.vault,
|
2022-05-25 17:29:06 -07:00
|
|
|
tokenAccount: wrappedSolAccount?.publicKey ?? tokenAccountPk,
|
2022-05-18 08:16:14 -07:00
|
|
|
tokenAuthority: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
2022-04-07 12:00:08 -07:00
|
|
|
})
|
|
|
|
.remainingAccounts(
|
|
|
|
healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({ pubkey: pk, isWritable: false, isSigner: false } as AccountMeta),
|
|
|
|
),
|
|
|
|
)
|
2022-05-25 17:29:06 -07:00
|
|
|
.preInstructions(preInstructions)
|
|
|
|
.postInstructions(postInstructions)
|
|
|
|
.signers(additionalSigners)
|
|
|
|
.rpc({ skipPreflight: true });
|
2022-04-07 09:58:42 -07:00
|
|
|
}
|
|
|
|
|
2022-07-04 03:09:33 -07:00
|
|
|
/**
|
|
|
|
* @deprecated
|
|
|
|
*/
|
2022-06-09 09:27:31 -07:00
|
|
|
public async tokenWithdraw(
|
2022-04-07 09:58:42 -07:00
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
2022-04-08 03:30:21 -07:00
|
|
|
tokenName: string,
|
2022-04-07 09:58:42 -07:00
|
|
|
amount: number,
|
|
|
|
allowBorrow: boolean,
|
|
|
|
) {
|
2022-04-08 03:30:21 -07:00
|
|
|
const bank = group.banksMap.get(tokenName)!;
|
|
|
|
|
2022-05-25 17:29:06 -07:00
|
|
|
const tokenAccountPk = await getAssociatedTokenAddress(
|
2022-04-07 09:58:42 -07:00
|
|
|
bank.mint,
|
|
|
|
mangoAccount.owner,
|
|
|
|
);
|
|
|
|
|
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
2022-05-31 18:38:47 -07:00
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount, [bank]);
|
2022-04-07 09:58:42 -07:00
|
|
|
|
2022-04-07 12:00:08 -07:00
|
|
|
return await this.program.methods
|
2022-06-09 09:27:31 -07:00
|
|
|
.tokenWithdraw(toNativeDecimals(amount, bank.mintDecimals), allowBorrow)
|
2022-04-07 12:00:08 -07:00
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
bank: bank.publicKey,
|
|
|
|
vault: bank.vault,
|
|
|
|
tokenAccount: tokenAccountPk,
|
|
|
|
})
|
|
|
|
.remainingAccounts(
|
|
|
|
healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({ pubkey: pk, isWritable: false, isSigner: false } as AccountMeta),
|
|
|
|
),
|
|
|
|
)
|
2022-06-29 12:55:39 -07:00
|
|
|
.rpc({ skipPreflight: true });
|
2022-04-07 09:58:42 -07:00
|
|
|
}
|
|
|
|
|
2022-07-04 03:09:33 -07:00
|
|
|
public async tokenWithdraw2(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
tokenName: string,
|
|
|
|
nativeAmount: number,
|
|
|
|
allowBorrow: boolean,
|
|
|
|
) {
|
|
|
|
const bank = group.banksMap.get(tokenName)!;
|
|
|
|
|
|
|
|
const tokenAccountPk = await getAssociatedTokenAddress(
|
|
|
|
bank.mint,
|
|
|
|
mangoAccount.owner,
|
|
|
|
);
|
|
|
|
|
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount, [bank]);
|
|
|
|
|
|
|
|
return await this.program.methods
|
|
|
|
.tokenWithdraw(new BN(nativeAmount), allowBorrow)
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
bank: bank.publicKey,
|
|
|
|
vault: bank.vault,
|
|
|
|
tokenAccount: tokenAccountPk,
|
|
|
|
})
|
|
|
|
.remainingAccounts(
|
|
|
|
healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({ pubkey: pk, isWritable: false, isSigner: false } as AccountMeta),
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.rpc({ skipPreflight: true });
|
|
|
|
}
|
|
|
|
|
2022-04-07 23:29:35 -07:00
|
|
|
// Serum
|
|
|
|
|
|
|
|
public async serum3RegisterMarket(
|
|
|
|
group: Group,
|
|
|
|
serum3MarketExternalPk: PublicKey,
|
|
|
|
baseBank: Bank,
|
|
|
|
quoteBank: Bank,
|
|
|
|
marketIndex: number,
|
2022-04-12 07:19:58 -07:00
|
|
|
name: string,
|
2022-04-07 23:29:35 -07:00
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
return await this.program.methods
|
2022-04-12 07:19:58 -07:00
|
|
|
.serum3RegisterMarket(marketIndex, name)
|
2022-04-07 23:29:35 -07:00
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
admin: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-06-11 04:49:45 -07:00
|
|
|
serumProgram: SERUM3_PROGRAM_ID[this.cluster],
|
2022-04-07 23:29:35 -07:00
|
|
|
serumMarketExternal: serum3MarketExternalPk,
|
|
|
|
baseBank: baseBank.publicKey,
|
|
|
|
quoteBank: quoteBank.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
payer: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 23:29:35 -07:00
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async serum3deregisterMarket(
|
|
|
|
group: Group,
|
|
|
|
serum3MarketName: string,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
const serum3Market = group.serum3MarketsMap.get(serum3MarketName)!;
|
|
|
|
|
|
|
|
return await this.program.methods
|
|
|
|
.serum3DeregisterMarket()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
serumMarket: serum3Market.publicKey,
|
|
|
|
solDestination: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
public async serum3GetMarkets(
|
2022-04-07 23:29:35 -07:00
|
|
|
group: Group,
|
2022-04-08 03:30:21 -07:00
|
|
|
baseTokenIndex?: number,
|
|
|
|
quoteTokenIndex?: number,
|
2022-04-07 23:29:35 -07:00
|
|
|
): Promise<Serum3Market[]> {
|
|
|
|
const bumpfbuf = Buffer.alloc(1);
|
|
|
|
bumpfbuf.writeUInt8(255);
|
|
|
|
|
2022-04-08 03:30:21 -07:00
|
|
|
const filters: MemcmpFilter[] = [
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: group.publicKey.toBase58(),
|
2022-04-12 07:19:58 -07:00
|
|
|
offset: 24,
|
2022-04-07 23:29:35 -07:00
|
|
|
},
|
2022-04-08 03:30:21 -07:00
|
|
|
},
|
|
|
|
];
|
|
|
|
|
|
|
|
if (baseTokenIndex) {
|
|
|
|
const bbuf = Buffer.alloc(2);
|
|
|
|
bbuf.writeUInt16LE(baseTokenIndex);
|
|
|
|
filters.push({
|
|
|
|
memcmp: {
|
|
|
|
bytes: bs58.encode(bbuf),
|
2022-04-12 07:19:58 -07:00
|
|
|
offset: 122,
|
2022-04-07 23:29:35 -07:00
|
|
|
},
|
2022-04-08 03:30:21 -07:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
if (quoteTokenIndex) {
|
|
|
|
const qbuf = Buffer.alloc(2);
|
|
|
|
qbuf.writeUInt16LE(quoteTokenIndex);
|
|
|
|
filters.push({
|
|
|
|
memcmp: {
|
|
|
|
bytes: bs58.encode(qbuf),
|
2022-04-12 07:19:58 -07:00
|
|
|
offset: 124,
|
2022-04-07 23:29:35 -07:00
|
|
|
},
|
2022-04-08 03:30:21 -07:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return (await this.program.account.serum3Market.all(filters)).map((tuple) =>
|
|
|
|
Serum3Market.from(tuple.publicKey, tuple.account),
|
|
|
|
);
|
2022-04-07 23:29:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
public async serum3CreateOpenOrders(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
2022-04-08 03:30:21 -07:00
|
|
|
marketName: string,
|
2022-04-07 23:29:35 -07:00
|
|
|
): Promise<TransactionSignature> {
|
2022-04-08 03:30:21 -07:00
|
|
|
const serum3Market: Serum3Market = group.serum3MarketsMap.get(marketName)!;
|
|
|
|
|
2022-04-07 23:29:35 -07:00
|
|
|
return await this.program.methods
|
|
|
|
.serum3CreateOpenOrders()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
serumMarket: serum3Market.publicKey,
|
|
|
|
serumProgram: serum3Market.serumProgram,
|
|
|
|
serumMarketExternal: serum3Market.serumMarketExternal,
|
2022-05-18 08:16:14 -07:00
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
|
|
|
payer: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-07 23:29:35 -07:00
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
public async serum3CloseOpenOrders(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
serum3MarketName: string,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
const serum3Market = group.serum3MarketsMap.get(serum3MarketName)!;
|
|
|
|
|
|
|
|
let openOrders = mangoAccount.serum3.find(
|
|
|
|
(account) => account.marketIndex === serum3Market.marketIndex,
|
|
|
|
)?.openOrders;
|
|
|
|
|
|
|
|
return await this.program.methods
|
|
|
|
.serum3CloseOpenOrders()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
serumMarket: serum3Market.publicKey,
|
|
|
|
serumProgram: serum3Market.serumProgram,
|
|
|
|
serumMarketExternal: serum3Market.serumMarketExternal,
|
|
|
|
openOrders,
|
|
|
|
solDestination: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-04-08 03:30:21 -07:00
|
|
|
public async serum3PlaceOrder(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
serum3MarketName: string,
|
|
|
|
side: Serum3Side,
|
2022-04-08 07:57:37 -07:00
|
|
|
price: number,
|
|
|
|
size: number,
|
2022-04-08 03:30:21 -07:00
|
|
|
selfTradeBehavior: Serum3SelfTradeBehavior,
|
|
|
|
orderType: Serum3OrderType,
|
|
|
|
clientOrderId: number,
|
|
|
|
limit: number,
|
|
|
|
) {
|
|
|
|
const serum3Market = group.serum3MarketsMap.get(serum3MarketName)!;
|
|
|
|
|
|
|
|
if (!mangoAccount.findSerum3Account(serum3Market.marketIndex)) {
|
|
|
|
await this.serum3CreateOpenOrders(group, mangoAccount, 'BTC/USDC');
|
|
|
|
mangoAccount = await this.getMangoAccount(mangoAccount);
|
|
|
|
}
|
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
const serum3MarketExternal =
|
|
|
|
group.serum3MarketExternalsMap.get(serum3MarketName)!;
|
2022-04-08 03:30:21 -07:00
|
|
|
|
|
|
|
const serum3MarketExternalVaultSigner =
|
|
|
|
await PublicKey.createProgramAddress(
|
|
|
|
[
|
|
|
|
serum3Market.serumMarketExternal.toBuffer(),
|
|
|
|
serum3MarketExternal.decoded.vaultSignerNonce.toArrayLike(
|
|
|
|
Buffer,
|
|
|
|
'le',
|
|
|
|
8,
|
|
|
|
),
|
|
|
|
],
|
2022-06-11 04:49:45 -07:00
|
|
|
SERUM3_PROGRAM_ID[this.cluster],
|
2022-04-08 03:30:21 -07:00
|
|
|
);
|
|
|
|
|
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount);
|
|
|
|
|
2022-04-08 07:57:37 -07:00
|
|
|
const limitPrice = serum3MarketExternal.priceNumberToLots(price);
|
|
|
|
const maxBaseQuantity = serum3MarketExternal.baseSizeNumberToLots(size);
|
|
|
|
const feeTier = getFeeTier(0, 0 /** TODO: fix msrm/srm balance */);
|
|
|
|
const rates = getFeeRates(feeTier);
|
|
|
|
const maxQuoteQuantity = new BN(
|
|
|
|
serum3MarketExternal.decoded.quoteLotSize.toNumber() *
|
|
|
|
(1 + rates.taker) /** TODO: fix taker/maker */,
|
|
|
|
).mul(
|
|
|
|
serum3MarketExternal
|
|
|
|
.baseSizeNumberToLots(size)
|
|
|
|
.mul(serum3MarketExternal.priceNumberToLots(price)),
|
|
|
|
);
|
|
|
|
|
2022-04-08 03:30:21 -07:00
|
|
|
return await this.program.methods
|
|
|
|
.serum3PlaceOrder(
|
|
|
|
side,
|
2022-04-08 07:57:37 -07:00
|
|
|
limitPrice,
|
|
|
|
maxBaseQuantity,
|
|
|
|
maxQuoteQuantity,
|
2022-04-08 03:30:21 -07:00
|
|
|
selfTradeBehavior,
|
|
|
|
orderType,
|
|
|
|
new BN(clientOrderId),
|
|
|
|
limit,
|
|
|
|
)
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-08 03:30:21 -07:00
|
|
|
openOrders: mangoAccount.findSerum3Account(serum3Market.marketIndex)
|
|
|
|
?.openOrders,
|
|
|
|
serumMarket: serum3Market.publicKey,
|
2022-06-11 04:49:45 -07:00
|
|
|
serumProgram: SERUM3_PROGRAM_ID[this.cluster],
|
2022-04-08 03:30:21 -07:00
|
|
|
serumMarketExternal: serum3Market.serumMarketExternal,
|
|
|
|
marketBids: serum3MarketExternal.bidsAddress,
|
|
|
|
marketAsks: serum3MarketExternal.asksAddress,
|
|
|
|
marketEventQueue: serum3MarketExternal.decoded.eventQueue,
|
|
|
|
marketRequestQueue: serum3MarketExternal.decoded.requestQueue,
|
|
|
|
marketBaseVault: serum3MarketExternal.decoded.baseVault,
|
|
|
|
marketQuoteVault: serum3MarketExternal.decoded.quoteVault,
|
|
|
|
marketVaultSigner: serum3MarketExternalVaultSigner,
|
|
|
|
quoteBank: group.findBank(serum3Market.quoteTokenIndex)?.publicKey,
|
|
|
|
quoteVault: group.findBank(serum3Market.quoteTokenIndex)?.vault,
|
|
|
|
baseBank: group.findBank(serum3Market.baseTokenIndex)?.publicKey,
|
|
|
|
baseVault: group.findBank(serum3Market.baseTokenIndex)?.vault,
|
|
|
|
})
|
|
|
|
.remainingAccounts(
|
|
|
|
healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({ pubkey: pk, isWritable: false, isSigner: false } as AccountMeta),
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
async serum3CancelAllorders(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
serum3MarketName: string,
|
|
|
|
limit: number,
|
|
|
|
) {
|
|
|
|
const serum3Market = group.serum3MarketsMap.get(serum3MarketName)!;
|
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
const serum3MarketExternal =
|
|
|
|
group.serum3MarketExternalsMap.get(serum3MarketName)!;
|
2022-06-09 09:27:31 -07:00
|
|
|
|
|
|
|
return await this.program.methods
|
|
|
|
.serum3CancelAllOrders(limit)
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
|
|
|
openOrders: mangoAccount.findSerum3Account(serum3Market.marketIndex)
|
|
|
|
?.openOrders,
|
|
|
|
serumMarket: serum3Market.publicKey,
|
2022-06-11 04:49:45 -07:00
|
|
|
serumProgram: SERUM3_PROGRAM_ID[this.cluster],
|
2022-06-09 09:27:31 -07:00
|
|
|
serumMarketExternal: serum3Market.serumMarketExternal,
|
|
|
|
marketBids: serum3MarketExternal.bidsAddress,
|
|
|
|
marketAsks: serum3MarketExternal.asksAddress,
|
|
|
|
marketEventQueue: serum3MarketExternal.decoded.eventQueue,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-04-08 11:47:12 -07:00
|
|
|
async serum3SettleFunds(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
serum3MarketName: string,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
const serum3Market = group.serum3MarketsMap.get(serum3MarketName)!;
|
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
const serum3MarketExternal =
|
|
|
|
group.serum3MarketExternalsMap.get(serum3MarketName)!;
|
2022-04-08 11:47:12 -07:00
|
|
|
|
|
|
|
const serum3MarketExternalVaultSigner =
|
|
|
|
// TODO: put into a helper method, and remove copy pasta
|
|
|
|
await PublicKey.createProgramAddress(
|
|
|
|
[
|
|
|
|
serum3Market.serumMarketExternal.toBuffer(),
|
|
|
|
serum3MarketExternal.decoded.vaultSignerNonce.toArrayLike(
|
|
|
|
Buffer,
|
|
|
|
'le',
|
|
|
|
8,
|
|
|
|
),
|
|
|
|
],
|
2022-06-11 04:49:45 -07:00
|
|
|
SERUM3_PROGRAM_ID[this.cluster],
|
2022-04-08 11:47:12 -07:00
|
|
|
);
|
|
|
|
|
|
|
|
return await this.program.methods
|
|
|
|
.serum3SettleFunds()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-04-08 11:47:12 -07:00
|
|
|
openOrders: mangoAccount.findSerum3Account(serum3Market.marketIndex)
|
|
|
|
?.openOrders,
|
|
|
|
serumMarket: serum3Market.publicKey,
|
2022-06-11 04:49:45 -07:00
|
|
|
serumProgram: SERUM3_PROGRAM_ID[this.cluster],
|
2022-04-08 11:47:12 -07:00
|
|
|
serumMarketExternal: serum3Market.serumMarketExternal,
|
|
|
|
marketBaseVault: serum3MarketExternal.decoded.baseVault,
|
|
|
|
marketQuoteVault: serum3MarketExternal.decoded.quoteVault,
|
|
|
|
marketVaultSigner: serum3MarketExternalVaultSigner,
|
|
|
|
quoteBank: group.findBank(serum3Market.quoteTokenIndex)?.publicKey,
|
|
|
|
quoteVault: group.findBank(serum3Market.quoteTokenIndex)?.vault,
|
|
|
|
baseBank: group.findBank(serum3Market.baseTokenIndex)?.publicKey,
|
|
|
|
baseVault: group.findBank(serum3Market.baseTokenIndex)?.vault,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
|
|
|
async serum3CancelOrder(
|
2022-04-08 07:57:37 -07:00
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
serum3MarketName: string,
|
|
|
|
side: Serum3Side,
|
|
|
|
orderId: BN,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
const serum3Market = group.serum3MarketsMap.get(serum3MarketName)!;
|
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
const serum3MarketExternal =
|
|
|
|
group.serum3MarketExternalsMap.get(serum3MarketName)!;
|
|
|
|
|
2022-04-08 07:57:37 -07:00
|
|
|
return await this.program.methods
|
|
|
|
.serum3CancelOrder(side, orderId)
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
openOrders: mangoAccount.findSerum3Account(serum3Market.marketIndex)
|
|
|
|
?.openOrders,
|
|
|
|
serumMarket: serum3Market.publicKey,
|
2022-06-11 04:49:45 -07:00
|
|
|
serumProgram: SERUM3_PROGRAM_ID[this.cluster],
|
2022-04-08 07:57:37 -07:00
|
|
|
serumMarketExternal: serum3Market.serumMarketExternal,
|
|
|
|
marketBids: serum3MarketExternal.bidsAddress,
|
|
|
|
marketAsks: serum3MarketExternal.asksAddress,
|
|
|
|
marketEventQueue: serum3MarketExternal.decoded.eventQueue,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
|
|
|
async getSerum3Orders(
|
|
|
|
group: Group,
|
|
|
|
serum3MarketName: string,
|
|
|
|
): Promise<Order[]> {
|
2022-06-11 04:49:45 -07:00
|
|
|
const serum3MarketExternal =
|
|
|
|
group.serum3MarketExternalsMap.get(serum3MarketName)!;
|
2022-04-08 07:57:37 -07:00
|
|
|
|
2022-05-27 22:05:34 -07:00
|
|
|
// TODO: filter for mango account
|
2022-04-08 07:57:37 -07:00
|
|
|
return await serum3MarketExternal.loadOrdersForOwner(
|
|
|
|
this.program.provider.connection,
|
|
|
|
group.publicKey,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-05-11 04:33:01 -07:00
|
|
|
/// perps
|
|
|
|
|
|
|
|
async perpCreateMarket(
|
|
|
|
group: Group,
|
|
|
|
oraclePk: PublicKey,
|
|
|
|
perpMarketIndex: number,
|
|
|
|
name: string,
|
2022-06-18 07:38:46 -07:00
|
|
|
oracleConfFilter: number,
|
2022-05-11 04:33:01 -07:00
|
|
|
baseTokenIndex: number,
|
2022-06-02 01:36:04 -07:00
|
|
|
baseTokenDecimals: number,
|
2022-05-11 04:33:01 -07:00
|
|
|
quoteTokenIndex: number,
|
|
|
|
quoteLotSize: number,
|
|
|
|
baseLotSize: number,
|
|
|
|
maintAssetWeight: number,
|
|
|
|
initAssetWeight: number,
|
|
|
|
maintLiabWeight: number,
|
|
|
|
initLiabWeight: number,
|
|
|
|
liquidationFee: number,
|
|
|
|
makerFee: number,
|
|
|
|
takerFee: number,
|
2022-05-17 06:06:29 -07:00
|
|
|
minFunding: number,
|
|
|
|
maxFunding: number,
|
|
|
|
impactQuantity: number,
|
2022-05-11 04:33:01 -07:00
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
const bids = new Keypair();
|
|
|
|
const asks = new Keypair();
|
|
|
|
const eventQueue = new Keypair();
|
|
|
|
|
|
|
|
return await this.program.methods
|
|
|
|
.perpCreateMarket(
|
|
|
|
perpMarketIndex,
|
|
|
|
name,
|
2022-06-18 07:38:46 -07:00
|
|
|
{
|
|
|
|
confFilter: {
|
|
|
|
val: I80F48.fromNumber(oracleConfFilter).getData(),
|
|
|
|
},
|
|
|
|
} as any, // future: nested custom types dont typecheck, fix if possible?
|
2022-05-11 04:33:01 -07:00
|
|
|
baseTokenIndex,
|
2022-06-02 01:36:04 -07:00
|
|
|
baseTokenDecimals,
|
2022-05-11 04:33:01 -07:00
|
|
|
quoteTokenIndex,
|
|
|
|
new BN(quoteLotSize),
|
|
|
|
new BN(baseLotSize),
|
|
|
|
maintAssetWeight,
|
|
|
|
initAssetWeight,
|
|
|
|
maintLiabWeight,
|
|
|
|
initLiabWeight,
|
|
|
|
liquidationFee,
|
|
|
|
makerFee,
|
|
|
|
takerFee,
|
2022-05-17 06:06:29 -07:00
|
|
|
minFunding,
|
|
|
|
maxFunding,
|
|
|
|
new BN(impactQuantity),
|
2022-05-11 04:33:01 -07:00
|
|
|
)
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
admin: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-05-11 04:33:01 -07:00
|
|
|
oracle: oraclePk,
|
|
|
|
bids: bids.publicKey,
|
|
|
|
asks: asks.publicKey,
|
|
|
|
eventQueue: eventQueue.publicKey,
|
2022-05-18 08:16:14 -07:00
|
|
|
payer: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-05-11 04:33:01 -07:00
|
|
|
})
|
|
|
|
.preInstructions([
|
2022-07-04 03:09:33 -07:00
|
|
|
// TODO: try to pick up sizes of bookside and eventqueue from IDL, so we can stay in sync with program
|
2022-05-11 04:33:01 -07:00
|
|
|
SystemProgram.createAccount({
|
|
|
|
programId: this.program.programId,
|
2022-07-04 03:09:33 -07:00
|
|
|
space: 8 + 90136,
|
2022-05-11 04:33:01 -07:00
|
|
|
lamports:
|
|
|
|
await this.program.provider.connection.getMinimumBalanceForRentExemption(
|
2022-07-04 03:09:33 -07:00
|
|
|
90144,
|
2022-05-11 04:33:01 -07:00
|
|
|
),
|
2022-05-18 08:16:14 -07:00
|
|
|
fromPubkey: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
2022-05-11 04:33:01 -07:00
|
|
|
newAccountPubkey: bids.publicKey,
|
|
|
|
}),
|
|
|
|
SystemProgram.createAccount({
|
|
|
|
programId: this.program.programId,
|
2022-07-04 03:09:33 -07:00
|
|
|
space: 8 + 90136,
|
2022-05-11 04:33:01 -07:00
|
|
|
lamports:
|
|
|
|
await this.program.provider.connection.getMinimumBalanceForRentExemption(
|
2022-07-04 03:09:33 -07:00
|
|
|
90144,
|
2022-05-11 04:33:01 -07:00
|
|
|
),
|
2022-05-18 08:16:14 -07:00
|
|
|
fromPubkey: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
2022-05-11 04:33:01 -07:00
|
|
|
newAccountPubkey: asks.publicKey,
|
|
|
|
}),
|
|
|
|
SystemProgram.createAccount({
|
|
|
|
programId: this.program.programId,
|
2022-07-04 03:09:33 -07:00
|
|
|
space: 8 + 102416,
|
2022-05-11 04:33:01 -07:00
|
|
|
lamports:
|
|
|
|
await this.program.provider.connection.getMinimumBalanceForRentExemption(
|
2022-07-04 03:09:33 -07:00
|
|
|
102424,
|
2022-05-11 04:33:01 -07:00
|
|
|
),
|
2022-05-18 08:16:14 -07:00
|
|
|
fromPubkey: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
2022-05-11 04:33:01 -07:00
|
|
|
newAccountPubkey: eventQueue.publicKey,
|
|
|
|
}),
|
|
|
|
])
|
|
|
|
.signers([bids, asks, eventQueue])
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-06-09 09:27:31 -07:00
|
|
|
async perpCloseMarket(
|
|
|
|
group: Group,
|
|
|
|
perpMarketName: string,
|
|
|
|
): Promise<TransactionSignature> {
|
|
|
|
const perpMarket = group.perpMarketsMap.get(perpMarketName)!;
|
|
|
|
|
|
|
|
return await this.program.methods
|
|
|
|
.perpCloseMarket()
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
admin: (this.program.provider as AnchorProvider).wallet.publicKey,
|
|
|
|
perpMarket: perpMarket.publicKey,
|
|
|
|
asks: perpMarket.asks,
|
|
|
|
bids: perpMarket.bids,
|
|
|
|
eventQueue: perpMarket.eventQueue,
|
|
|
|
solDestination: (this.program.provider as AnchorProvider).wallet
|
|
|
|
.publicKey,
|
|
|
|
})
|
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
public async perpGetMarkets(
|
2022-05-11 04:33:01 -07:00
|
|
|
group: Group,
|
|
|
|
baseTokenIndex?: number,
|
|
|
|
quoteTokenIndex?: number,
|
|
|
|
): Promise<PerpMarket[]> {
|
|
|
|
const bumpfbuf = Buffer.alloc(1);
|
|
|
|
bumpfbuf.writeUInt8(255);
|
|
|
|
|
|
|
|
const filters: MemcmpFilter[] = [
|
|
|
|
{
|
|
|
|
memcmp: {
|
|
|
|
bytes: group.publicKey.toBase58(),
|
|
|
|
offset: 24,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
];
|
|
|
|
|
|
|
|
if (baseTokenIndex) {
|
|
|
|
const bbuf = Buffer.alloc(2);
|
|
|
|
bbuf.writeUInt16LE(baseTokenIndex);
|
|
|
|
filters.push({
|
|
|
|
memcmp: {
|
|
|
|
bytes: bs58.encode(bbuf),
|
2022-06-20 03:52:27 -07:00
|
|
|
offset: 444,
|
2022-05-11 04:33:01 -07:00
|
|
|
},
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
if (quoteTokenIndex) {
|
|
|
|
const qbuf = Buffer.alloc(2);
|
|
|
|
qbuf.writeUInt16LE(quoteTokenIndex);
|
|
|
|
filters.push({
|
|
|
|
memcmp: {
|
|
|
|
bytes: bs58.encode(qbuf),
|
2022-06-20 03:52:27 -07:00
|
|
|
offset: 446,
|
2022-05-11 04:33:01 -07:00
|
|
|
},
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
return (await this.program.account.perpMarket.all(filters)).map((tuple) =>
|
|
|
|
PerpMarket.from(tuple.publicKey, tuple.account),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
async perpPlaceOrder(
|
|
|
|
group: Group,
|
|
|
|
mangoAccount: MangoAccount,
|
|
|
|
perpMarketName: string,
|
|
|
|
side: Side,
|
2022-06-02 10:30:39 -07:00
|
|
|
price: number,
|
|
|
|
quantity: number,
|
|
|
|
maxQuoteQuantity: number,
|
2022-05-11 04:33:01 -07:00
|
|
|
clientOrderId: number,
|
|
|
|
orderType: OrderType,
|
|
|
|
expiryTimestamp: number,
|
|
|
|
limit: number,
|
|
|
|
) {
|
|
|
|
const perpMarket = group.perpMarketsMap.get(perpMarketName)!;
|
|
|
|
|
2022-06-02 10:30:39 -07:00
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount);
|
|
|
|
|
|
|
|
let [nativePrice, nativeQuantity] = perpMarket.uiToNativePriceQuantity(
|
|
|
|
price,
|
|
|
|
quantity,
|
|
|
|
);
|
|
|
|
|
|
|
|
const maxQuoteQuantityLots = maxQuoteQuantity
|
|
|
|
? perpMarket.uiQuoteToLots(maxQuoteQuantity)
|
|
|
|
: I64_MAX_BN;
|
|
|
|
|
2022-05-11 04:33:01 -07:00
|
|
|
await this.program.methods
|
|
|
|
.perpPlaceOrder(
|
|
|
|
side,
|
2022-06-02 10:30:39 -07:00
|
|
|
nativePrice,
|
|
|
|
nativeQuantity,
|
|
|
|
maxQuoteQuantityLots,
|
2022-05-11 04:33:01 -07:00
|
|
|
new BN(clientOrderId),
|
|
|
|
orderType,
|
|
|
|
new BN(expiryTimestamp),
|
|
|
|
limit,
|
|
|
|
)
|
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
perpMarket: perpMarket.publicKey,
|
|
|
|
asks: perpMarket.asks,
|
|
|
|
bids: perpMarket.bids,
|
|
|
|
eventQueue: perpMarket.eventQueue,
|
|
|
|
oracle: perpMarket.oracle,
|
2022-05-18 08:16:14 -07:00
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
2022-05-11 04:33:01 -07:00
|
|
|
})
|
2022-06-02 10:30:39 -07:00
|
|
|
.remainingAccounts(
|
|
|
|
healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({ pubkey: pk, isWritable: false, isSigner: false } as AccountMeta),
|
|
|
|
),
|
|
|
|
)
|
2022-05-11 04:33:01 -07:00
|
|
|
.rpc();
|
|
|
|
}
|
|
|
|
|
2022-05-24 11:10:01 -07:00
|
|
|
public async marginTrade({
|
|
|
|
group,
|
|
|
|
mangoAccount,
|
|
|
|
inputToken,
|
|
|
|
amountIn,
|
|
|
|
outputToken,
|
2022-06-24 07:41:04 -07:00
|
|
|
slippage = 0.5,
|
2022-05-24 11:10:01 -07:00
|
|
|
}: {
|
|
|
|
group: Group;
|
|
|
|
mangoAccount: MangoAccount;
|
|
|
|
inputToken: string;
|
|
|
|
amountIn: number;
|
|
|
|
outputToken: string;
|
2022-06-24 07:41:04 -07:00
|
|
|
slippage: number;
|
2022-05-24 11:10:01 -07:00
|
|
|
}): Promise<TransactionSignature> {
|
2022-05-31 18:38:47 -07:00
|
|
|
const inputBank = group.banksMap.get(inputToken);
|
|
|
|
const outputBank = group.banksMap.get(outputToken);
|
|
|
|
|
|
|
|
if (!inputBank || !outputBank) throw new Error('Invalid token');
|
|
|
|
|
2022-05-24 11:10:01 -07:00
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
2022-05-31 18:38:47 -07:00
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount, [
|
|
|
|
inputBank,
|
|
|
|
outputBank,
|
|
|
|
]);
|
2022-05-24 11:10:01 -07:00
|
|
|
const parsedHealthAccounts = healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({
|
|
|
|
pubkey: pk,
|
2022-05-31 18:38:47 -07:00
|
|
|
isWritable:
|
|
|
|
pk.equals(inputBank.publicKey) || pk.equals(outputBank.publicKey)
|
|
|
|
? true
|
|
|
|
: false,
|
2022-05-24 11:10:01 -07:00
|
|
|
isSigner: false,
|
|
|
|
} as AccountMeta),
|
|
|
|
);
|
|
|
|
|
2022-06-23 03:58:43 -07:00
|
|
|
/*
|
2022-06-24 07:41:04 -07:00
|
|
|
* Find or create associated token accounts
|
2022-06-23 03:58:43 -07:00
|
|
|
*/
|
2022-06-24 07:41:04 -07:00
|
|
|
let inputTokenAccountPk = await getAssociatedTokenAddress(
|
2022-06-23 03:58:43 -07:00
|
|
|
inputBank.mint,
|
|
|
|
mangoAccount.owner,
|
|
|
|
);
|
2022-06-24 07:41:04 -07:00
|
|
|
const inputTokenAccExists =
|
|
|
|
await this.program.provider.connection.getAccountInfo(
|
|
|
|
inputTokenAccountPk,
|
|
|
|
);
|
2022-06-23 03:58:43 -07:00
|
|
|
let preInstructions = [];
|
2022-06-24 07:41:04 -07:00
|
|
|
if (!inputTokenAccExists) {
|
2022-06-23 03:58:43 -07:00
|
|
|
preInstructions.push(
|
2022-06-24 07:41:04 -07:00
|
|
|
Token.createAssociatedTokenAccountInstruction(
|
2022-06-23 03:58:43 -07:00
|
|
|
mangoAccount.owner,
|
2022-06-24 07:41:04 -07:00
|
|
|
inputTokenAccountPk,
|
2022-06-23 03:58:43 -07:00
|
|
|
mangoAccount.owner,
|
|
|
|
inputBank.mint,
|
|
|
|
TOKEN_PROGRAM_ID,
|
|
|
|
ASSOCIATED_TOKEN_PROGRAM_ID,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-06-24 07:41:04 -07:00
|
|
|
let outputTokenAccountPk = await getAssociatedTokenAddress(
|
|
|
|
outputBank.mint,
|
|
|
|
mangoAccount.owner,
|
|
|
|
);
|
|
|
|
const outputTokenAccExists =
|
|
|
|
await this.program.provider.connection.getAccountInfo(
|
|
|
|
outputTokenAccountPk,
|
|
|
|
);
|
|
|
|
if (!outputTokenAccExists) {
|
|
|
|
preInstructions.push(
|
|
|
|
Token.createAssociatedTokenAccountInstruction(
|
|
|
|
mangoAccount.owner,
|
|
|
|
outputTokenAccountPk,
|
|
|
|
mangoAccount.owner,
|
|
|
|
outputBank.mint,
|
|
|
|
TOKEN_PROGRAM_ID,
|
|
|
|
ASSOCIATED_TOKEN_PROGRAM_ID,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-06-23 03:58:43 -07:00
|
|
|
/*
|
2022-06-24 07:41:04 -07:00
|
|
|
* Transfer input token to users wallet, then swap with the Jupiter route,
|
|
|
|
* and finally transfer output token from users wallet back to the mango vault
|
2022-06-23 03:58:43 -07:00
|
|
|
*/
|
2022-06-24 07:41:04 -07:00
|
|
|
const nativeInputAmount = toU64(
|
|
|
|
amountIn,
|
|
|
|
inputBank.mintDecimals,
|
|
|
|
).toNumber();
|
2022-06-23 03:58:43 -07:00
|
|
|
const instructions: TransactionInstruction[] = [];
|
2022-06-24 07:41:04 -07:00
|
|
|
|
|
|
|
const transferIx = Token.createTransferInstruction(
|
|
|
|
TOKEN_PROGRAM_ID,
|
2022-06-23 03:58:43 -07:00
|
|
|
inputBank.vault,
|
2022-06-24 07:41:04 -07:00
|
|
|
inputTokenAccountPk,
|
2022-06-23 03:58:43 -07:00
|
|
|
inputBank.publicKey,
|
|
|
|
[],
|
2022-06-24 07:41:04 -07:00
|
|
|
nativeInputAmount,
|
2022-06-23 03:58:43 -07:00
|
|
|
);
|
|
|
|
const inputBankKey = transferIx.keys[2];
|
|
|
|
transferIx.keys[2] = { ...inputBankKey, isWritable: true, isSigner: false };
|
|
|
|
instructions.push(transferIx);
|
2022-06-29 20:36:57 -07:00
|
|
|
|
|
|
|
// TODO: move out of client and into ui
|
|
|
|
// Start Jupiter
|
2022-06-24 07:41:04 -07:00
|
|
|
|
|
|
|
const jupiter = await Jupiter.load({
|
|
|
|
connection: this.program.provider.connection,
|
|
|
|
cluster: 'mainnet-beta',
|
|
|
|
user: mangoAccount.owner, // or public key
|
|
|
|
// platformFeeAndAccounts: NO_PLATFORM_FEE,
|
|
|
|
routeCacheDuration: 10_000, // Will not refetch data on computeRoutes for up to 10 seconds
|
|
|
|
});
|
2022-05-24 11:10:01 -07:00
|
|
|
|
2022-06-24 07:41:04 -07:00
|
|
|
const routes = await jupiter.computeRoutes({
|
|
|
|
inputMint: inputBank.mint, // Mint address of the input token
|
|
|
|
outputMint: outputBank.mint, // Mint address of the output token
|
|
|
|
inputAmount: nativeInputAmount, // raw input amount of tokens
|
|
|
|
slippage, // The slippage in % terms
|
|
|
|
forceFetch: false, // false is the default value => will use cache if not older than routeCacheDuration
|
|
|
|
});
|
|
|
|
|
2022-06-24 10:01:57 -07:00
|
|
|
const routesInfosWithoutRaydium = routes.routesInfos.filter((r) => {
|
|
|
|
if (r.marketInfos.length > 1) {
|
|
|
|
for (const mkt of r.marketInfos) {
|
|
|
|
if (mkt.amm.label === 'Raydium' || mkt.amm.label === 'Serum')
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
});
|
|
|
|
|
|
|
|
const selectedRoute = routesInfosWithoutRaydium[0];
|
|
|
|
|
2022-06-24 07:41:04 -07:00
|
|
|
console.log(
|
2022-06-24 10:01:57 -07:00
|
|
|
`route found: ${selectedRoute.marketInfos[0].amm.label}. generating jup transaction`,
|
2022-06-24 07:41:04 -07:00
|
|
|
);
|
|
|
|
|
|
|
|
const { transactions } = await jupiter.exchange({
|
2022-06-24 10:01:57 -07:00
|
|
|
routeInfo: selectedRoute,
|
2022-06-24 07:41:04 -07:00
|
|
|
});
|
|
|
|
console.log('Jupiter Transactions:', transactions);
|
|
|
|
const { setupTransaction, swapTransaction } = transactions;
|
|
|
|
|
|
|
|
for (const ix of swapTransaction.instructions) {
|
|
|
|
if (
|
|
|
|
ix.programId.toBase58() ===
|
|
|
|
'JUP2jxvXaqu7NQY1GmNF4m1vodw12LVXYxbFL2uJvfo'
|
|
|
|
) {
|
|
|
|
instructions.push(ix);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-29 20:36:57 -07:00
|
|
|
// End Jupiter
|
|
|
|
|
2022-06-24 07:41:04 -07:00
|
|
|
const transferIx2 = Token.createTransferInstruction(
|
|
|
|
TOKEN_PROGRAM_ID,
|
|
|
|
outputTokenAccountPk,
|
|
|
|
outputBank.vault,
|
2022-06-23 03:58:43 -07:00
|
|
|
mangoAccount.owner,
|
|
|
|
[],
|
2022-06-24 10:01:57 -07:00
|
|
|
selectedRoute.outAmountWithSlippage,
|
2022-05-24 11:10:01 -07:00
|
|
|
);
|
2022-06-23 03:58:43 -07:00
|
|
|
instructions.push(transferIx2);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Build data objects for margin trade instructions
|
|
|
|
*/
|
|
|
|
const targetRemainingAccounts = instructions
|
|
|
|
.map((ix) => [
|
|
|
|
{
|
|
|
|
pubkey: ix.programId,
|
|
|
|
isWritable: false,
|
|
|
|
isSigner: false,
|
|
|
|
} as AccountMeta,
|
|
|
|
...ix.keys,
|
|
|
|
])
|
|
|
|
.flat();
|
|
|
|
|
2022-06-23 07:41:24 -07:00
|
|
|
const vaultIndex = targetRemainingAccounts
|
2022-06-24 07:41:04 -07:00
|
|
|
.map((x) => x.pubkey.toString())
|
|
|
|
.lastIndexOf(inputBank.vault.toString());
|
2022-06-23 07:41:24 -07:00
|
|
|
|
2022-06-23 01:19:33 -07:00
|
|
|
const withdraws: FlashLoanWithdraw[] = [
|
2022-06-23 07:41:24 -07:00
|
|
|
{
|
2022-06-24 10:01:57 -07:00
|
|
|
index: vaultIndex,
|
2022-06-23 07:41:24 -07:00
|
|
|
amount: toU64(amountIn, inputBank.mintDecimals),
|
|
|
|
},
|
2022-05-31 18:38:47 -07:00
|
|
|
];
|
2022-06-23 03:58:43 -07:00
|
|
|
|
|
|
|
let cpiDatas = [];
|
|
|
|
for (const [index, ix] of instructions.entries()) {
|
|
|
|
if (index === 0) {
|
|
|
|
cpiDatas.push({
|
|
|
|
accountStart: new BN(parsedHealthAccounts.length),
|
|
|
|
data: ix.data,
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
cpiDatas.push({
|
|
|
|
accountStart: cpiDatas[index - 1].accountStart.add(
|
|
|
|
new BN(instructions[index - 1].keys.length + 1),
|
|
|
|
),
|
|
|
|
data: ix.data,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-24 07:41:04 -07:00
|
|
|
console.log(
|
|
|
|
'instructions',
|
|
|
|
instructions.map((i) => ({ ...i, programId: i.programId.toString() })),
|
|
|
|
);
|
2022-06-23 03:58:43 -07:00
|
|
|
console.log('cpiDatas', cpiDatas);
|
|
|
|
console.log(
|
|
|
|
'targetRemainingAccounts',
|
|
|
|
targetRemainingAccounts.map((t) => ({
|
|
|
|
...t,
|
|
|
|
pubkey: t.pubkey.toString(),
|
|
|
|
})),
|
|
|
|
);
|
2022-05-24 11:10:01 -07:00
|
|
|
|
2022-06-24 07:41:04 -07:00
|
|
|
if (setupTransaction) {
|
|
|
|
await this.program.provider.sendAndConfirm(setupTransaction);
|
|
|
|
} else if (preInstructions.length) {
|
|
|
|
const tx = new Transaction();
|
|
|
|
for (const ix of preInstructions) {
|
|
|
|
tx.add(ix);
|
|
|
|
}
|
|
|
|
console.log('preInstructions', preInstructions);
|
|
|
|
|
|
|
|
await this.program.provider.sendAndConfirm(tx);
|
|
|
|
}
|
|
|
|
|
2022-05-24 11:10:01 -07:00
|
|
|
return await this.program.methods
|
2022-06-23 07:02:35 -07:00
|
|
|
.flashLoan(withdraws, cpiDatas)
|
2022-05-24 11:10:01 -07:00
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
|
|
|
})
|
2022-06-23 03:58:43 -07:00
|
|
|
.remainingAccounts([...parsedHealthAccounts, ...targetRemainingAccounts])
|
2022-05-31 18:38:47 -07:00
|
|
|
.rpc({ skipPreflight: true });
|
2022-05-24 11:10:01 -07:00
|
|
|
}
|
|
|
|
|
2022-06-29 20:36:57 -07:00
|
|
|
public async marginTrade3({
|
|
|
|
group,
|
|
|
|
mangoAccount,
|
|
|
|
inputToken,
|
|
|
|
amountIn,
|
|
|
|
outputToken,
|
2022-07-06 21:45:01 -07:00
|
|
|
userDefinedInstructions,
|
2022-06-29 20:36:57 -07:00
|
|
|
}: {
|
|
|
|
group: Group;
|
|
|
|
mangoAccount: MangoAccount;
|
|
|
|
inputToken: string;
|
|
|
|
amountIn: number;
|
|
|
|
outputToken: string;
|
2022-07-06 21:45:01 -07:00
|
|
|
userDefinedInstructions: TransactionInstruction[];
|
2022-06-29 20:36:57 -07:00
|
|
|
}): Promise<TransactionSignature> {
|
|
|
|
const inputBank = group.banksMap.get(inputToken);
|
|
|
|
const outputBank = group.banksMap.get(outputToken);
|
|
|
|
|
|
|
|
if (!inputBank || !outputBank) throw new Error('Invalid token');
|
|
|
|
|
|
|
|
const healthRemainingAccounts: PublicKey[] =
|
|
|
|
await this.buildHealthRemainingAccounts(group, mangoAccount, [
|
|
|
|
inputBank,
|
|
|
|
outputBank,
|
|
|
|
]);
|
|
|
|
const parsedHealthAccounts = healthRemainingAccounts.map(
|
|
|
|
(pk) =>
|
|
|
|
({
|
|
|
|
pubkey: pk,
|
2022-07-06 21:45:01 -07:00
|
|
|
isWritable: false,
|
2022-06-29 20:36:57 -07:00
|
|
|
isSigner: false,
|
|
|
|
} as AccountMeta),
|
|
|
|
);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find or create associated token accounts
|
|
|
|
*/
|
|
|
|
let inputTokenAccountPk = await getAssociatedTokenAddress(
|
|
|
|
inputBank.mint,
|
|
|
|
mangoAccount.owner,
|
|
|
|
);
|
|
|
|
const inputTokenAccExists =
|
|
|
|
await this.program.provider.connection.getAccountInfo(
|
|
|
|
inputTokenAccountPk,
|
|
|
|
);
|
|
|
|
let preInstructions = [];
|
|
|
|
if (!inputTokenAccExists) {
|
|
|
|
preInstructions.push(
|
|
|
|
Token.createAssociatedTokenAccountInstruction(
|
|
|
|
mangoAccount.owner,
|
|
|
|
inputTokenAccountPk,
|
|
|
|
mangoAccount.owner,
|
|
|
|
inputBank.mint,
|
|
|
|
TOKEN_PROGRAM_ID,
|
|
|
|
ASSOCIATED_TOKEN_PROGRAM_ID,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
let outputTokenAccountPk = await getAssociatedTokenAddress(
|
|
|
|
outputBank.mint,
|
|
|
|
mangoAccount.owner,
|
|
|
|
);
|
|
|
|
const outputTokenAccExists =
|
|
|
|
await this.program.provider.connection.getAccountInfo(
|
|
|
|
outputTokenAccountPk,
|
|
|
|
);
|
|
|
|
if (!outputTokenAccExists) {
|
|
|
|
preInstructions.push(
|
|
|
|
Token.createAssociatedTokenAccountInstruction(
|
|
|
|
mangoAccount.owner,
|
|
|
|
outputTokenAccountPk,
|
|
|
|
mangoAccount.owner,
|
|
|
|
outputBank.mint,
|
|
|
|
TOKEN_PROGRAM_ID,
|
|
|
|
ASSOCIATED_TOKEN_PROGRAM_ID,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-07-06 21:45:01 -07:00
|
|
|
if (preInstructions.length) {
|
2022-06-29 20:36:57 -07:00
|
|
|
const tx = new Transaction();
|
|
|
|
for (const ix of preInstructions) {
|
|
|
|
tx.add(ix);
|
|
|
|
}
|
|
|
|
console.log('preInstructions', preInstructions);
|
|
|
|
|
|
|
|
await this.program.provider.sendAndConfirm(tx);
|
|
|
|
}
|
|
|
|
|
2022-07-07 10:04:54 -07:00
|
|
|
const inputBankAccount = {
|
2022-06-29 20:36:57 -07:00
|
|
|
pubkey: inputBank.publicKey,
|
2022-07-06 21:45:01 -07:00
|
|
|
isWritable: true,
|
2022-06-29 20:36:57 -07:00
|
|
|
isSigner: false,
|
|
|
|
};
|
2022-07-07 10:04:54 -07:00
|
|
|
const outputBankAccount = {
|
2022-07-06 21:45:01 -07:00
|
|
|
pubkey: outputBank.publicKey,
|
2022-06-29 20:36:57 -07:00
|
|
|
isWritable: true,
|
2022-07-06 21:45:01 -07:00
|
|
|
isSigner: false,
|
|
|
|
};
|
2022-07-07 10:04:54 -07:00
|
|
|
const inputBankVault = {
|
2022-06-29 20:36:57 -07:00
|
|
|
pubkey: inputBank.vault,
|
2022-07-06 21:45:01 -07:00
|
|
|
isWritable: true,
|
2022-06-29 20:36:57 -07:00
|
|
|
isSigner: false,
|
|
|
|
};
|
2022-07-07 10:04:54 -07:00
|
|
|
const outputBankVault = {
|
2022-07-06 21:45:01 -07:00
|
|
|
pubkey: outputBank.vault,
|
2022-06-29 20:36:57 -07:00
|
|
|
isWritable: true,
|
2022-07-06 21:45:01 -07:00
|
|
|
isSigner: false,
|
|
|
|
};
|
2022-07-07 10:04:54 -07:00
|
|
|
const inputATA = {
|
2022-06-29 20:36:57 -07:00
|
|
|
pubkey: inputTokenAccountPk,
|
2022-07-06 21:45:01 -07:00
|
|
|
isWritable: true,
|
|
|
|
isSigner: false,
|
|
|
|
};
|
2022-07-07 10:04:54 -07:00
|
|
|
const outputATA = {
|
2022-07-06 21:45:01 -07:00
|
|
|
pubkey: outputTokenAccountPk,
|
|
|
|
isWritable: false,
|
|
|
|
isSigner: false,
|
2022-06-29 20:36:57 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
const flashLoanEndIx = await this.program.methods
|
|
|
|
.flashLoan3End()
|
|
|
|
.accounts({
|
|
|
|
account: mangoAccount.publicKey,
|
|
|
|
owner: (this.program.provider as AnchorProvider).wallet.publicKey,
|
|
|
|
})
|
2022-07-06 21:45:01 -07:00
|
|
|
.remainingAccounts([
|
|
|
|
...parsedHealthAccounts,
|
2022-07-07 10:04:54 -07:00
|
|
|
inputBankVault,
|
|
|
|
outputBankVault,
|
|
|
|
inputATA,
|
2022-07-06 21:45:01 -07:00
|
|
|
{
|
|
|
|
isWritable: true,
|
|
|
|
pubkey: outputTokenAccountPk,
|
|
|
|
isSigner: false,
|
|
|
|
},
|
|
|
|
])
|
2022-06-29 20:36:57 -07:00
|
|
|
.instruction();
|
|
|
|
|
2022-07-07 13:43:19 -07:00
|
|
|
const flashLoanBeginIx = await this.program.methods
|
2022-07-06 21:45:01 -07:00
|
|
|
.flashLoan3Begin([
|
|
|
|
toNativeDecimals(amountIn, inputBank.mintDecimals),
|
|
|
|
new BN(
|
|
|
|
0,
|
|
|
|
) /* we don't care about borrowing the target amount, this is just a dummy */,
|
|
|
|
])
|
2022-06-29 20:36:57 -07:00
|
|
|
.accounts({
|
|
|
|
group: group.publicKey,
|
2022-07-06 21:45:01 -07:00
|
|
|
instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
|
2022-06-29 20:36:57 -07:00
|
|
|
})
|
2022-07-06 21:45:01 -07:00
|
|
|
.remainingAccounts([
|
2022-07-07 10:04:54 -07:00
|
|
|
inputBankAccount,
|
|
|
|
outputBankAccount,
|
|
|
|
inputBankVault,
|
|
|
|
outputBankVault,
|
|
|
|
inputATA,
|
|
|
|
outputATA,
|
2022-07-06 21:45:01 -07:00
|
|
|
])
|
|
|
|
.instruction();
|
|
|
|
|
|
|
|
const tx = new Transaction();
|
2022-07-07 13:43:19 -07:00
|
|
|
tx.add(flashLoanBeginIx);
|
2022-07-06 21:45:01 -07:00
|
|
|
for (const i of userDefinedInstructions) {
|
|
|
|
tx.add(i);
|
|
|
|
}
|
|
|
|
tx.add(flashLoanEndIx);
|
|
|
|
return this.program.provider.sendAndConfirm(tx);
|
|
|
|
}
|
2022-06-18 07:31:28 -07:00
|
|
|
/// liquidations
|
|
|
|
|
|
|
|
// TODO
|
|
|
|
// async liqTokenWithToken(
|
|
|
|
// assetTokenIndex: number,
|
|
|
|
// liabTokenIndex: number,
|
|
|
|
// maxLiabTransfer: number,
|
|
|
|
// ): Promise<TransactionSignature> {
|
|
|
|
// return await this.program.methods
|
|
|
|
// .liqTokenWithToken(assetTokenIndex, liabTokenIndex, {
|
|
|
|
// val: I80F48.fromNumber(maxLiabTransfer).getData(),
|
|
|
|
// })
|
|
|
|
// .rpc();
|
|
|
|
// }
|
|
|
|
|
2022-04-07 09:58:42 -07:00
|
|
|
/// static
|
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
static connect(
|
|
|
|
provider: Provider,
|
|
|
|
cluster: Cluster,
|
|
|
|
programId: PublicKey,
|
|
|
|
): MangoClient {
|
2022-03-31 23:59:39 -07:00
|
|
|
// TODO: use IDL on chain or in repository? decide...
|
2022-03-31 04:55:59 -07:00
|
|
|
// Alternatively we could fetch IDL from chain.
|
|
|
|
// const idl = await Program.fetchIdl(MANGO_V4_ID, provider);
|
2022-03-31 00:10:06 -07:00
|
|
|
let idl = IDL;
|
|
|
|
|
2022-02-23 02:09:17 -08:00
|
|
|
return new MangoClient(
|
2022-06-11 04:49:45 -07:00
|
|
|
new Program<MangoV4>(idl as MangoV4, programId, provider),
|
|
|
|
programId,
|
|
|
|
cluster,
|
2022-06-21 11:04:21 -07:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
static connectForGroupName(
|
|
|
|
provider: Provider,
|
|
|
|
groupName: string,
|
|
|
|
): MangoClient {
|
|
|
|
// TODO: use IDL on chain or in repository? decide...
|
|
|
|
// Alternatively we could fetch IDL from chain.
|
|
|
|
// const idl = await Program.fetchIdl(MANGO_V4_ID, provider);
|
|
|
|
let idl = IDL;
|
|
|
|
|
|
|
|
const id = Id.fromIds(groupName);
|
|
|
|
|
|
|
|
return new MangoClient(
|
|
|
|
new Program<MangoV4>(
|
|
|
|
idl as MangoV4,
|
2022-06-23 06:22:59 -07:00
|
|
|
new PublicKey(id.mangoProgramId),
|
2022-06-21 11:04:21 -07:00
|
|
|
provider,
|
|
|
|
),
|
2022-06-23 06:22:59 -07:00
|
|
|
new PublicKey(id.mangoProgramId),
|
2022-06-21 11:04:21 -07:00
|
|
|
id.cluster,
|
|
|
|
groupName,
|
2022-02-23 02:09:17 -08:00
|
|
|
);
|
|
|
|
}
|
2022-04-07 08:16:46 -07:00
|
|
|
|
2022-04-07 09:58:42 -07:00
|
|
|
/// private
|
2022-04-07 08:58:20 -07:00
|
|
|
|
2022-07-04 03:09:33 -07:00
|
|
|
public async buildHealthRemainingAccounts(
|
2022-04-07 08:58:20 -07:00
|
|
|
group: Group,
|
2022-04-07 09:58:42 -07:00
|
|
|
mangoAccount: MangoAccount,
|
2022-05-31 18:38:47 -07:00
|
|
|
banks?: Bank[] /** TODO for serum3PlaceOrder we are just ingoring this atm */,
|
2022-04-07 09:58:42 -07:00
|
|
|
) {
|
|
|
|
const healthRemainingAccounts: PublicKey[] = [];
|
2022-04-07 08:58:20 -07:00
|
|
|
|
2022-04-08 03:30:21 -07:00
|
|
|
const tokenIndices = mangoAccount.tokens
|
|
|
|
.filter((token) => token.tokenIndex !== 65535)
|
|
|
|
.map((token) => token.tokenIndex);
|
|
|
|
|
2022-05-31 18:38:47 -07:00
|
|
|
if (banks?.length) {
|
|
|
|
for (const bank of banks) {
|
|
|
|
tokenIndices.push(bank.tokenIndex);
|
|
|
|
}
|
2022-04-07 09:58:42 -07:00
|
|
|
}
|
2022-04-08 03:30:21 -07:00
|
|
|
|
2022-06-11 04:49:45 -07:00
|
|
|
const mintInfos = [...new Set(tokenIndices)].map(
|
|
|
|
(tokenIndex) => group.mintInfosMap.get(tokenIndex)!,
|
2022-04-08 03:30:21 -07:00
|
|
|
);
|
2022-06-27 02:27:17 -07:00
|
|
|
healthRemainingAccounts.push(
|
|
|
|
...mintInfos.map((mintInfo) => mintInfo.firstBank()),
|
|
|
|
);
|
2022-04-08 03:30:21 -07:00
|
|
|
healthRemainingAccounts.push(
|
2022-06-11 04:49:45 -07:00
|
|
|
...mintInfos.map((mintInfo) => mintInfo.oracle),
|
2022-04-08 03:30:21 -07:00
|
|
|
);
|
|
|
|
healthRemainingAccounts.push(
|
|
|
|
...mangoAccount.serum3
|
|
|
|
.filter((serum3Account) => serum3Account.marketIndex !== 65535)
|
|
|
|
.map((serum3Account) => serum3Account.openOrders),
|
|
|
|
);
|
2022-05-11 04:33:01 -07:00
|
|
|
healthRemainingAccounts.push(
|
|
|
|
...mangoAccount.perps
|
|
|
|
.filter((perp) => perp.marketIndex !== 65535)
|
|
|
|
.map(
|
|
|
|
(perp) =>
|
|
|
|
Array.from(group.perpMarketsMap.values()).filter(
|
|
|
|
(perpMarket) => perpMarket.perpMarketIndex === perp.marketIndex,
|
|
|
|
)[0].publicKey,
|
|
|
|
),
|
|
|
|
);
|
2022-04-08 03:30:21 -07:00
|
|
|
|
2022-04-07 09:58:42 -07:00
|
|
|
return healthRemainingAccounts;
|
2022-04-07 08:58:20 -07:00
|
|
|
}
|
2022-02-23 02:09:17 -08:00
|
|
|
}
|