491 lines
14 KiB
TypeScript
491 lines
14 KiB
TypeScript
import { AnchorProvider, Wallet } from '@coral-xyz/anchor';
|
|
import { BN } from '@project-serum/anchor';
|
|
import { serializeInstructionToBase64 } from '@solana/spl-governance';
|
|
import {
|
|
Connection,
|
|
Keypair,
|
|
PublicKey,
|
|
SystemProgram,
|
|
TransactionInstruction,
|
|
} from '@solana/web3.js';
|
|
import fs from 'fs';
|
|
import { PerpMarketIndex } from '../src/accounts/perp';
|
|
import { Builder } from '../src/builder';
|
|
import { MangoClient } from '../src/client';
|
|
import {
|
|
NullPerpEditParams,
|
|
TrueIxGateParams,
|
|
buildIxGate,
|
|
} from '../src/clientIxParamBuilder';
|
|
import { MANGO_V4_ID } from '../src/constants';
|
|
import { bpsToDecimal, percentageToDecimal, toNative } from '../src/utils';
|
|
|
|
const { MB_CLUSTER_URL, MB_PAYER_KEYPAIR } = process.env;
|
|
|
|
const CLIENT_USER = MB_PAYER_KEYPAIR;
|
|
const GROUP_PK = '78b8f4cGCwmZ9ysPFMWLaLTkkaYnUjwMJYStWe5RTSSX';
|
|
|
|
const defaultOracleConfig = {
|
|
confFilter: 0.1,
|
|
maxStalenessSlots: 120,
|
|
};
|
|
|
|
const defaultInterestRate = {
|
|
adjustmentFactor: 0.004,
|
|
util0: 0.7,
|
|
rate0: 0.1,
|
|
util1: 0.85,
|
|
rate1: 0.2,
|
|
maxRate: 2.0,
|
|
};
|
|
|
|
async function buildClient(): Promise<MangoClient> {
|
|
const clientKeypair = Keypair.fromSecretKey(
|
|
Buffer.from(JSON.parse(fs.readFileSync(CLIENT_USER!, 'utf-8'))),
|
|
);
|
|
|
|
const options = AnchorProvider.defaultOptions();
|
|
const connection = new Connection(MB_CLUSTER_URL!, options);
|
|
|
|
const clientWallet = new Wallet(clientKeypair);
|
|
const clientProvider = new AnchorProvider(connection, clientWallet, options);
|
|
|
|
return await MangoClient.connect(
|
|
clientProvider,
|
|
'mainnet-beta',
|
|
MANGO_V4_ID['mainnet-beta'],
|
|
{
|
|
idsSource: 'get-program-accounts',
|
|
},
|
|
);
|
|
}
|
|
|
|
// async function groupEdit(): Promise<void> {
|
|
// const client = await buildClient();
|
|
// const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
// const ix = await client.program.methods
|
|
// .groupEdit(
|
|
// null, // admin
|
|
// null, // fastListingAdmin
|
|
// null, // securityAdmin
|
|
// null, // testing
|
|
// null, // version
|
|
// null, // depositLimitQuote
|
|
// null, // feesPayWithMngo
|
|
// null, // feesMngoBonusRate
|
|
// null, // feesSwapMangoAccount
|
|
// 6, // feesMngoTokenIndex
|
|
// null, // feesExpiryInterval
|
|
// 5, // allowedFastListingsPerInterval
|
|
// )
|
|
// .accounts({
|
|
// group: group.publicKey,
|
|
// admin: group.admin,
|
|
// })
|
|
// .instruction();
|
|
// console.log(serializeInstructionToBase64(ix));
|
|
// }
|
|
|
|
// async function tokenRegister(): Promise<void> {
|
|
// const client = await buildClient();
|
|
|
|
// const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
|
|
// const ix = await client.program.methods
|
|
// .tokenRegister(
|
|
// 8 as TokenIndex,
|
|
// 'wBTC (Portal)',
|
|
// defaultOracleConfig,
|
|
// defaultInterestRate,
|
|
// bpsToDecimal(50),
|
|
// bpsToDecimal(5),
|
|
// 0.9,
|
|
// 0.8,
|
|
// 1.1,
|
|
// 1.2,
|
|
// percentageToDecimal(5),
|
|
// 60 * 60,
|
|
// 0.06,
|
|
// 0.0003,
|
|
// percentageToDecimal(20),
|
|
// new BN(24 * 60 * 60),
|
|
// new BN(toNative(50000, 6).toNumber()),
|
|
// 5_000_000_000,
|
|
// 5_000_000_000,
|
|
// 0,
|
|
// 0.0005,
|
|
// 0.0005,
|
|
// 0.0005,
|
|
// )
|
|
// .accounts({
|
|
// group: group.publicKey,
|
|
// admin: group.admin,
|
|
// mint: new PublicKey('3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh'),
|
|
// oracle: new PublicKey('GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU'),
|
|
// payer: (client.program.provider as AnchorProvider).wallet.publicKey,
|
|
// rent: SYSVAR_RENT_PUBKEY,
|
|
// })
|
|
// .instruction();
|
|
|
|
// // const coder = new BorshCoder(IDL);
|
|
// // console.log(coder.instruction.decode(ix.data));
|
|
|
|
// console.log(await serializeInstructionToBase64(ix));
|
|
// }
|
|
|
|
// async function tokenEdit(): Promise<void> {
|
|
// const client = await buildClient();
|
|
|
|
// const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
|
|
// const params = Builder(NullTokenEditParams)
|
|
// .borrowWeightScaleStartQuote(new BN(toNative(100000, 6)).toNumber())
|
|
// .depositWeightScaleStartQuote(new BN(toNative(100000, 6)).toNumber())
|
|
// .build();
|
|
// const ix = await client.program.methods
|
|
// .tokenEdit(
|
|
// params.oracle,
|
|
// params.oracleConfig,
|
|
// params.groupInsuranceFund,
|
|
// params.interestRateParams,
|
|
// params.loanFeeRate,
|
|
// params.loanOriginationFeeRate,
|
|
// params.maintAssetWeight,
|
|
// params.initAssetWeight,
|
|
// params.maintLiabWeight,
|
|
// params.initLiabWeight,
|
|
// params.liquidationFee,
|
|
// params.stablePriceDelayIntervalSeconds,
|
|
// params.stablePriceDelayGrowthLimit,
|
|
// params.stablePriceGrowthLimit,
|
|
// params.minVaultToDepositsRatio,
|
|
// params.netBorrowLimitPerWindowQuote !== null
|
|
// ? new BN(params.netBorrowLimitPerWindowQuote)
|
|
// : null,
|
|
// params.netBorrowLimitWindowSizeTs !== null
|
|
// ? new BN(params.netBorrowLimitWindowSizeTs)
|
|
// : null,
|
|
// params.borrowWeightScaleStartQuote,
|
|
// params.depositWeightScaleStartQuote,
|
|
// params.resetStablePrice ?? false,
|
|
// params.resetNetBorrowLimit ?? false,
|
|
// params.reduceOnly,
|
|
// params.name,
|
|
// params.forceClose,
|
|
// params.tokenConditionalSwapTakerFeeRate,
|
|
// params.tokenConditionalSwapMakerFeeRate,
|
|
// params.flashLoanSwapFeeRate,
|
|
// )
|
|
// .accounts({
|
|
// group: group.publicKey,
|
|
// oracle: new PublicKey('GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU'),
|
|
// admin: group.admin,
|
|
// mintInfo: new PublicKey('59rgC1pa45EziDPyFgJgE7gbv7Dd7VaGmd2D93i1dtFk'),
|
|
// })
|
|
// .remainingAccounts([
|
|
// {
|
|
// pubkey: new PublicKey('8gabXzwdPn5TvtuQvysh3CxVbjfNY3TZd5XEG5qnueUm'),
|
|
// isWritable: true,
|
|
// isSigner: false,
|
|
// } as AccountMeta,
|
|
// ])
|
|
// .instruction();
|
|
// console.log(serializeInstructionToBase64(ix));
|
|
// }
|
|
|
|
// async function serum3Register(): Promise<void> {
|
|
// const client = await buildClient();
|
|
|
|
// const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
|
|
// const ix = await client.program.methods
|
|
// .serum3RegisterMarket(3, 'ETH (Portal)/USDC',)
|
|
// .accounts({
|
|
// group: group.publicKey,
|
|
// admin: group.admin,
|
|
// serumProgram: OPENBOOK_PROGRAM_ID['mainnet-beta'],
|
|
// serumMarketExternal: new PublicKey(
|
|
// 'BbJgE7HZMaDp5NTYvRh5jZSkQPVDTU8ubPFtpogUkEj4',
|
|
// ),
|
|
// baseBank: group.getFirstBankByMint(
|
|
// new PublicKey('7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs'),
|
|
// ).publicKey,
|
|
// quoteBank: group.getFirstBankByMint(
|
|
// new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
|
|
// ).publicKey,
|
|
// payer: (client.program.provider as AnchorProvider).wallet.publicKey,
|
|
// })
|
|
// .instruction();
|
|
|
|
// console.log(serializeInstructionToBase64(ix));
|
|
// }
|
|
|
|
async function perpCreate(): Promise<void> {
|
|
const client = await buildClient();
|
|
|
|
const bids = new Keypair();
|
|
const asks = new Keypair();
|
|
const eventQueue = new Keypair();
|
|
|
|
const bookSideSize = (client.program as any)._coder.accounts.size(
|
|
(client.program.account.bookSide as any)._idlAccount,
|
|
);
|
|
const eventQueueSize = (client.program as any)._coder.accounts.size(
|
|
(client.program.account.eventQueue as any)._idlAccount,
|
|
);
|
|
|
|
const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
|
|
const ix = await client.program.methods
|
|
.perpCreateMarket(
|
|
2,
|
|
'SOL-PERP',
|
|
defaultOracleConfig,
|
|
9,
|
|
new BN(100),
|
|
new BN(10000000),
|
|
0.9,
|
|
0.8,
|
|
1.1,
|
|
1.2,
|
|
0,
|
|
0,
|
|
percentageToDecimal(5),
|
|
bpsToDecimal(-1),
|
|
bpsToDecimal(4),
|
|
percentageToDecimal(-5),
|
|
percentageToDecimal(5),
|
|
new BN(100),
|
|
false,
|
|
bpsToDecimal(0.5),
|
|
toNative(0.0001, 6).toNumber(),
|
|
toNative(100, 6).toNumber(),
|
|
percentageToDecimal(1),
|
|
0,
|
|
1,
|
|
new BN(60 * 60),
|
|
percentageToDecimal(10),
|
|
0,
|
|
)
|
|
.accounts({
|
|
group: group.publicKey,
|
|
admin: group.admin,
|
|
oracle: new PublicKey('H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG'),
|
|
bids: bids.publicKey,
|
|
asks: asks.publicKey,
|
|
eventQueue: eventQueue.publicKey,
|
|
payer: (client.program.provider as AnchorProvider).wallet.publicKey,
|
|
})
|
|
.preInstructions([
|
|
// book sides
|
|
SystemProgram.createAccount({
|
|
programId: client.program.programId,
|
|
space: bookSideSize,
|
|
lamports:
|
|
await client.program.provider.connection.getMinimumBalanceForRentExemption(
|
|
bookSideSize,
|
|
),
|
|
fromPubkey: (client.program.provider as AnchorProvider).wallet
|
|
.publicKey,
|
|
newAccountPubkey: bids.publicKey,
|
|
}),
|
|
SystemProgram.createAccount({
|
|
programId: client.program.programId,
|
|
space: bookSideSize,
|
|
lamports:
|
|
await client.program.provider.connection.getMinimumBalanceForRentExemption(
|
|
bookSideSize,
|
|
),
|
|
fromPubkey: (client.program.provider as AnchorProvider).wallet
|
|
.publicKey,
|
|
newAccountPubkey: asks.publicKey,
|
|
}),
|
|
// event queue
|
|
SystemProgram.createAccount({
|
|
programId: client.program.programId,
|
|
space: eventQueueSize,
|
|
lamports:
|
|
await client.program.provider.connection.getMinimumBalanceForRentExemption(
|
|
eventQueueSize,
|
|
),
|
|
fromPubkey: (client.program.provider as AnchorProvider).wallet
|
|
.publicKey,
|
|
newAccountPubkey: eventQueue.publicKey,
|
|
}),
|
|
])
|
|
.signers([bids, asks, eventQueue])
|
|
.instruction();
|
|
console.log(serializeInstructionToBase64(ix));
|
|
}
|
|
|
|
async function perpEdit(): Promise<void> {
|
|
const client = await buildClient();
|
|
const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
const perpMarket = group.getPerpMarketByMarketIndex(0 as PerpMarketIndex);
|
|
const params = Builder(NullPerpEditParams)
|
|
.positivePnlLiquidationFee(bpsToDecimal(250))
|
|
.build();
|
|
const ix = await client.program.methods
|
|
.perpEditMarket(
|
|
params.oracle,
|
|
params.oracleConfig,
|
|
params.baseDecimals,
|
|
params.maintBaseAssetWeight,
|
|
params.initBaseAssetWeight,
|
|
params.maintBaseLiabWeight,
|
|
params.initBaseLiabWeight,
|
|
params.maintOverallAssetWeight,
|
|
params.initOverallAssetWeight,
|
|
params.baseLiquidationFee,
|
|
params.makerFee,
|
|
params.takerFee,
|
|
params.minFunding,
|
|
params.maxFunding,
|
|
params.impactQuantity !== null ? new BN(params.impactQuantity) : null,
|
|
params.groupInsuranceFund,
|
|
params.feePenalty,
|
|
params.settleFeeFlat,
|
|
params.settleFeeAmountThreshold,
|
|
params.settleFeeFractionLowHealth,
|
|
params.stablePriceDelayIntervalSeconds,
|
|
params.stablePriceDelayGrowthLimit,
|
|
params.stablePriceGrowthLimit,
|
|
params.settlePnlLimitFactor,
|
|
params.settlePnlLimitWindowSize !== null
|
|
? new BN(params.settlePnlLimitWindowSize)
|
|
: null,
|
|
params.reduceOnly,
|
|
params.resetStablePrice ?? false,
|
|
params.positivePnlLiquidationFee,
|
|
params.name,
|
|
params.forceClose,
|
|
params.platformLiquidationFee,
|
|
)
|
|
.accounts({
|
|
group: group.publicKey,
|
|
oracle: params.oracle ?? perpMarket.oracle,
|
|
admin: group.admin,
|
|
perpMarket: perpMarket.publicKey,
|
|
})
|
|
.instruction();
|
|
console.log(serializeInstructionToBase64(ix));
|
|
}
|
|
|
|
async function ixDisable(): Promise<void> {
|
|
const client = await buildClient();
|
|
|
|
const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
|
|
const ixGateParams = TrueIxGateParams;
|
|
ixGateParams.HealthRegion = false;
|
|
const ix = await client.program.methods
|
|
.ixGateSet(buildIxGate(ixGateParams))
|
|
.accounts({
|
|
group: group.publicKey,
|
|
admin: group.securityAdmin,
|
|
})
|
|
.instruction();
|
|
|
|
console.log(await serializeInstructionToBase64(ix));
|
|
}
|
|
|
|
async function createMangoAccount(): Promise<void> {
|
|
const client = await buildClient();
|
|
|
|
const group = await client.getGroup(new PublicKey(GROUP_PK));
|
|
|
|
const ix = await client.program.methods
|
|
.accountCreate(0, 8, 8, 4, 32, 'Mango DAO 0')
|
|
.accounts({
|
|
group: group.publicKey,
|
|
owner: new PublicKey('5tgfd6XgwiXB9otEnzFpXK11m7Q7yZUaAJzWK4oT5UGF'),
|
|
payer: new PublicKey('5tgfd6XgwiXB9otEnzFpXK11m7Q7yZUaAJzWK4oT5UGF'),
|
|
})
|
|
.instruction();
|
|
|
|
console.log(await serializeInstructionToBase64(ix));
|
|
}
|
|
|
|
async function idlResize(): Promise<void> {
|
|
// anchor constant for all idl-specific instructions
|
|
const idlIxBytes = [0x40, 0xf4, 0xbc, 0x78, 0xa7, 0xe9, 0x69, 0x0a];
|
|
const idlIxNum = 6; // resize
|
|
const newSize = new BN(19000);
|
|
const ix = new TransactionInstruction({
|
|
keys: [
|
|
{
|
|
pubkey: new PublicKey('3foqXduY5PabCn6LjNrLo3waNf3Hy6vQgqavoVUCsUN9'), // idl account
|
|
isSigner: false,
|
|
isWritable: true,
|
|
},
|
|
{
|
|
pubkey: new PublicKey('FP4PxqHTVzeG2c6eZd7974F9WvKUSdBeduUK3rjYyvBw'), // authority
|
|
isSigner: true,
|
|
isWritable: true,
|
|
},
|
|
{
|
|
pubkey: new PublicKey('11111111111111111111111111111111'), // system program
|
|
isSigner: false,
|
|
isWritable: false,
|
|
},
|
|
],
|
|
programId: MANGO_V4_ID['mainnet-beta'],
|
|
data: Buffer.from(idlIxBytes.concat([idlIxNum], newSize.toArray('le', 8))),
|
|
});
|
|
|
|
console.log(await serializeInstructionToBase64(ix));
|
|
}
|
|
|
|
async function idlSetAuthority(): Promise<void> {
|
|
// anchor constant for all idl-specific instructions
|
|
const idlIxBytes = [0x40, 0xf4, 0xbc, 0x78, 0xa7, 0xe9, 0x69, 0x0a];
|
|
const idlIxNum = 4; // setAuthority
|
|
const newAuthority = new PublicKey(
|
|
'8SSLjXBEVk9nesbhi9UMCA32uijbVBUqWoKPPQPTekzt',
|
|
);
|
|
const ix = new TransactionInstruction({
|
|
keys: [
|
|
{
|
|
pubkey: new PublicKey('3foqXduY5PabCn6LjNrLo3waNf3Hy6vQgqavoVUCsUN9'), // idl account
|
|
isSigner: false,
|
|
isWritable: true,
|
|
},
|
|
{
|
|
pubkey: new PublicKey('FP4PxqHTVzeG2c6eZd7974F9WvKUSdBeduUK3rjYyvBw'), // authority
|
|
isSigner: true,
|
|
isWritable: true,
|
|
},
|
|
],
|
|
programId: MANGO_V4_ID['mainnet-beta'],
|
|
data: Buffer.concat([
|
|
Buffer.from(idlIxBytes.concat([idlIxNum])),
|
|
newAuthority.toBuffer(),
|
|
]),
|
|
});
|
|
|
|
console.log(await serializeInstructionToBase64(ix));
|
|
}
|
|
|
|
async function main(): Promise<void> {
|
|
try {
|
|
// await groupEdit();
|
|
// await tokenRegister();
|
|
// await tokenEdit();
|
|
// await perpCreate();
|
|
// await perpEdit();
|
|
// await serum3Register();
|
|
// await ixDisable();
|
|
// await createMangoAccount();
|
|
// await idlResize();
|
|
// await idlSetAuthority();
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|
|
}
|
|
|
|
try {
|
|
main();
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|