1510 lines
46 KiB
TypeScript
1510 lines
46 KiB
TypeScript
const bs58 = require('bs58');
|
|
import {
|
|
MangoInstructionLayout,
|
|
IDS,
|
|
Config,
|
|
GroupConfig,
|
|
PerpMarketConfig,
|
|
orderTypeLayout,
|
|
} from '@blockworks-foundation/mango-client';
|
|
import { getLatestObjPerCombination } from './utils';
|
|
|
|
|
|
// Unfortunately ids.json does not correspond to the token indexes in the log - so keep a map here for reference
|
|
// mango group -> token index -> mint key
|
|
// TODO: is there a better way?
|
|
var tokenIndexesMap = {
|
|
'98pjRuQjK3qA6gXts96PqZT4Ze5QmnCmt3QYjhbUSPue': {
|
|
0: 'MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac',
|
|
1: '9n4nbM75f5Ui33ZbPYXn59EwSgE8CGsHtAeTH5YFeJ9E',
|
|
2: '2FPyTwcZLUg1MDrwsyoP4D6s1tM7hAkHYRjkNb5w6Pxk',
|
|
3: 'So11111111111111111111111111111111111111112',
|
|
4: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
|
|
5: 'SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt',
|
|
6: '4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
|
|
7: '8HGyAAB1yoM1ttS7pXjHMa3dukTFGQggnFFH3hJZgzQh',
|
|
15: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
|
|
},
|
|
'4yJ2Vx3kZnmHTNCrHzdoj5nCwriF2kVhfKNvqC6gU8tr': {
|
|
0: 'MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac',
|
|
1: '9n4nbM75f5Ui33ZbPYXn59EwSgE8CGsHtAeTH5YFeJ9E',
|
|
2: '2FPyTwcZLUg1MDrwsyoP4D6s1tM7hAkHYRjkNb5w6Pxk',
|
|
3: 'So11111111111111111111111111111111111111112',
|
|
4: 'SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt',
|
|
5: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
|
|
15: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
|
|
},
|
|
};
|
|
|
|
// mango group -> token index -> mint key
|
|
var oracleIndexesMap = {
|
|
'98pjRuQjK3qA6gXts96PqZT4Ze5QmnCmt3QYjhbUSPue': {
|
|
0: '49cnp1ejyvQi3CJw3kKXNCDGnNbWDuZd3UG3Y2zGvQkX',
|
|
1: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
|
|
2: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
|
|
3: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
|
|
4: '3vxLXJqLqF3JG5TCbYycbKWRBbCJQLxQmBGCkyqEEefL',
|
|
5: '3NBReDRTLKMQEKiLD5tGcx4kXbTf88b7f2xLS9UuGjym',
|
|
6: 'AnLf8tVYCM816gmBjiy8n53eXKKEDydT5piYjjQDPgTB',
|
|
7: '9xYBiDWYsh2fHzpsz3aaCnNHCKWBNtfEDLtU6kS4aFD9',
|
|
},
|
|
'4yJ2Vx3kZnmHTNCrHzdoj5nCwriF2kVhfKNvqC6gU8tr': {
|
|
0: '49cnp1ejyvQi3CJw3kKXNCDGnNbWDuZd3UG3Y2zGvQkX',
|
|
1: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
|
|
2: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
|
|
3: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
|
|
4: '3NBReDRTLKMQEKiLD5tGcx4kXbTf88b7f2xLS9UuGjym',
|
|
5: '3vxLXJqLqF3JG5TCbYycbKWRBbCJQLxQmBGCkyqEEefL',
|
|
},
|
|
};
|
|
|
|
// Lot sizes also not available on ids.json
|
|
// mango group -> perp name -> lot sizes
|
|
var perpLotSizes = {
|
|
'98pjRuQjK3qA6gXts96PqZT4Ze5QmnCmt3QYjhbUSPue': {
|
|
'BTC-PERP': {
|
|
'baseLotSize': 100,
|
|
'quoteLotSize': 10
|
|
},
|
|
'SOL-PERP': {
|
|
'baseLotSize': 10000000,
|
|
'quoteLotSize': 100
|
|
}
|
|
}
|
|
}
|
|
|
|
var ids = IDS;
|
|
|
|
export function jsonParser(parsedTransactions, result, instructions, signature, blockTime, slot, blockDatetime) {
|
|
|
|
// Go through all instructions and get the update funding stuff first
|
|
parsedTransactions.funding.push(
|
|
...extractUpdateFundings(
|
|
result,
|
|
instructions,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
)
|
|
);
|
|
|
|
parsedTransactions.net_balances.push(
|
|
...extractNetBalances(
|
|
result.transaction.message.accountKeys,
|
|
result.meta.logMessages,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
)
|
|
);
|
|
|
|
parsedTransactions.settle_fees.push(
|
|
...extractSettleFees(
|
|
result.transaction.message.accountKeys,
|
|
result.meta.logMessages,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
)
|
|
);
|
|
|
|
parsedTransactions.settle_pnl.push(
|
|
...extractSettlePnl(
|
|
result.transaction.message.accountKeys,
|
|
result.meta.logMessages,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
)
|
|
);
|
|
|
|
// Can have multiple inserts per signature so add instructionNum column to allow a primary key
|
|
for (let instruction of instructions) {
|
|
const instructionName = instruction.instructionName;
|
|
const instructionNum = instruction.instructionNum;
|
|
|
|
if (instructionName === 'CachePrices') {
|
|
parsedTransactions.cache_prices.push(
|
|
...parseCachePrices(
|
|
instructionNum,
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'CacheRootBanks') {
|
|
parsedTransactions.cache_indexes.push(
|
|
...parseCacheRootBanks(
|
|
instructionNum,
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'Deposit') {
|
|
parsedTransactions.deposits_withdraws.push(
|
|
...parseDepositWithDraw(
|
|
instruction,
|
|
instructionNum,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'Withdraw') {
|
|
parsedTransactions.deposits_withdraws.push(
|
|
...parseDepositWithDraw(
|
|
instruction,
|
|
instructionNum,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'LiquidateTokenAndToken') {
|
|
parsedTransactions.liquidate_token_and_token.push(
|
|
...parseLiquidateTokenAndToken(
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'LiquidateTokenAndPerp') {
|
|
parsedTransactions.liquidate_token_and_perp.push(
|
|
...parseLiquidateTokenAndPerp(
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'LiquidatePerpMarket') {
|
|
parsedTransactions.liquidate_perp_market.push(
|
|
...parseLiquidatePerpMarket(
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'ResolveTokenBankruptcy') {
|
|
parsedTransactions.token_bankruptcy.push(
|
|
...parseResolveTokenBankruptcy(
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'ResolvePerpBankruptcy') {
|
|
parsedTransactions.perp_bankruptcy.push(
|
|
...parseResolvePerpBankruptcy(
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'ConsumeEvents') {
|
|
// if (instructionName === 'ConsumeEvents') {
|
|
|
|
parsedTransactions.fill_events.push(
|
|
...parseConsumeEvents(
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
// }
|
|
} else if (instructionName === 'RedeemMngo') {
|
|
parsedTransactions.redeem_mngo.push(
|
|
...parseRedeemMngo(
|
|
instruction,
|
|
result.meta.innerInstructions,
|
|
instructionNum,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'ForceSettleQuotePositions') {
|
|
parsedTransactions.force_settle_quote_positions.push(
|
|
...parseForceSettleQuotePositions(
|
|
result.meta.logMessages,
|
|
instruction.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
} else if (instructionName === 'UpdateFunding') {
|
|
// read through the program logs and filter for the one that starts with open curly bracket
|
|
// TODO what about the case where it's part of a CPI?
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
function extractSettleFees(
|
|
allAccounts,
|
|
logMessages,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
|
|
// Need to know the mango group pk of the transaction for information not tied to instructions
|
|
// Transaction will only have one mango group - so check which one it is by iterating over mango group pks in IDS
|
|
// TODO: add mango group to appropriate log messages and remove this workaround
|
|
let ids = IDS;
|
|
console.log();
|
|
let mangoGroupPk;
|
|
let accountKeys = allAccounts.map(
|
|
(e) => e.pubkey,
|
|
);
|
|
for (let pk of ids.groups.map((e) => e.publicKey)) {
|
|
if (accountKeys.includes(pk)) {
|
|
mangoGroupPk = pk;
|
|
break;
|
|
}
|
|
}
|
|
|
|
let startDetailsStr = 'Program log: settle_fees details: '
|
|
const filteredLogs = logMessages.filter((line) =>
|
|
line.startsWith(startDetailsStr),
|
|
);
|
|
|
|
let instructionNum = 1;
|
|
let out: any = []
|
|
for (let log of filteredLogs) {
|
|
let perpMarkets = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'perpMarkets'
|
|
];
|
|
|
|
// Log JSON is missing quotes around mango accounts
|
|
// Also trailing comma at end of json
|
|
// TODO: fix this
|
|
let settlePnlDetails;
|
|
try {
|
|
settlePnlDetails = JSON.parse(log.slice(startDetailsStr.length));
|
|
} catch {
|
|
let jsonString = log.slice(startDetailsStr.length);
|
|
jsonString = insertQuotesAroundField(jsonString, 'mango_account');
|
|
|
|
jsonString = jsonString.replace(', }', ' }');
|
|
|
|
settlePnlDetails = JSON.parse(jsonString);
|
|
}
|
|
|
|
let mangoAccount = settlePnlDetails['mango_account'];
|
|
|
|
let marketIndex = settlePnlDetails['market_index'];
|
|
let perpMarket = perpMarkets.find(
|
|
(e) => e['marketIndex'] === marketIndex,
|
|
);
|
|
let perpMarketName = perpMarket.name;
|
|
|
|
let settlement =
|
|
settlePnlDetails['settlement'] / Math.pow(10, perpMarket.quoteDecimals);
|
|
|
|
out.push(...[
|
|
{
|
|
margin_account: mangoAccount,
|
|
settlement: settlement,
|
|
perp_market_name: perpMarketName,
|
|
instruction_num: instructionNum,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
])
|
|
|
|
instructionNum++;
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
function extractSettlePnl(
|
|
allAccounts,
|
|
logMessages,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
|
|
// Need to know the mango group pk of the transaction for information not tied to instructions
|
|
// Transaction will only have one mango group - so check which one it is by iterating over mango group pks in IDS
|
|
// TODO: add mango group to appropriate log messages and remove this workaround
|
|
let ids = IDS;
|
|
console.log();
|
|
let mangoGroupPk;
|
|
let accountKeys = allAccounts.map(
|
|
(e) => e.pubkey,
|
|
);
|
|
for (let pk of ids.groups.map((e) => e.publicKey)) {
|
|
if (accountKeys.includes(pk)) {
|
|
mangoGroupPk = pk;
|
|
break;
|
|
}
|
|
}
|
|
|
|
let startDetailsStr = 'Program log: settle_pnl details: '
|
|
const filteredLogs = logMessages.filter((line) =>
|
|
line.startsWith(startDetailsStr),
|
|
);
|
|
|
|
let instructionNum = 1;
|
|
let out: any = []
|
|
for (let log of filteredLogs) {
|
|
let perpMarkets = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'perpMarkets'
|
|
];
|
|
|
|
// Log JSON is missing quotes around mango accounts
|
|
// TODO: fix this
|
|
let settlePnlDetails;
|
|
try {
|
|
settlePnlDetails = JSON.parse(log.slice(startDetailsStr.length));
|
|
} catch {
|
|
let jsonString = log.slice(startDetailsStr.length);
|
|
jsonString = insertQuotesAroundField(jsonString, 'mango_account_a');
|
|
jsonString = insertQuotesAroundField(jsonString, 'mango_account_b');
|
|
|
|
settlePnlDetails = JSON.parse(jsonString);
|
|
}
|
|
|
|
let mangoAccountA = settlePnlDetails['mango_account_a'];
|
|
let mangoAccountB = settlePnlDetails['mango_account_b'];
|
|
|
|
let marketIndex = settlePnlDetails['market_index'];
|
|
let perpMarket = perpMarkets.find(
|
|
(e) => e['marketIndex'] === marketIndex,
|
|
);
|
|
let perpMarketName = perpMarket.name;
|
|
|
|
let settlement = settlePnlDetails['settlement'];
|
|
|
|
// A's quote position is reduced by settlement and B's quote position is increased by settlement
|
|
let settlementA = (-1 * settlement) / Math.pow(10, perpMarket.quoteDecimals);
|
|
let settlementB = settlement / Math.pow(10, perpMarket.quoteDecimals);
|
|
|
|
out.push(...[
|
|
{
|
|
margin_account: mangoAccountA,
|
|
settlement: settlementA,
|
|
perp_market_name: perpMarketName,
|
|
counterparty: mangoAccountB,
|
|
instruction_num: instructionNum,
|
|
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
{
|
|
margin_account: mangoAccountB,
|
|
settlement: settlementB,
|
|
perp_market_name: perpMarketName,
|
|
counterparty: mangoAccountA,
|
|
instruction_num: instructionNum,
|
|
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
]);
|
|
|
|
instructionNum++;
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
function insertQuotesAroundField(jsonString, field) {
|
|
// Utility function to fix malformed json (json with quotes around strings)
|
|
// Assumes fields have a single space before the key
|
|
|
|
let firstQuotePosition =
|
|
jsonString.search('"' + field + '": ') + ('"' + field + '": ').length;
|
|
let secondQuotePosition =
|
|
firstQuotePosition + jsonString.slice(firstQuotePosition).search(',');
|
|
|
|
return [
|
|
jsonString.slice(0, firstQuotePosition),
|
|
'"',
|
|
jsonString.slice(firstQuotePosition, secondQuotePosition),
|
|
'"',
|
|
jsonString.slice(secondQuotePosition),
|
|
].join('');
|
|
}
|
|
|
|
function getJsonStringsFromArray(logMessages, jsonStartStr) {
|
|
let jsonStrings: any = [];
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(jsonStartStr)) {
|
|
jsonStrings.push(logMessage.slice(jsonStartStr.length));
|
|
}
|
|
}
|
|
|
|
return jsonStrings;
|
|
}
|
|
|
|
function parseConsumeEvents(
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
// instructionNum is used here to form a primary key on the db table (with signature)
|
|
|
|
|
|
let mangoGroupPk = accounts[0];
|
|
|
|
let perpMarkets = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'perpMarkets'
|
|
];
|
|
|
|
let perpMarketPk = accounts[2];
|
|
|
|
let perpMarket = perpMarkets.find(
|
|
(e) => e['publicKey'] === perpMarketPk,
|
|
);
|
|
|
|
let lotSizes = perpLotSizes[mangoGroupPk][perpMarket.name]
|
|
|
|
let events: any = [];
|
|
let startDetailsStr = 'Program log: FillEvent details: ';
|
|
let eventNum = 1;
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let eventDetails;
|
|
try {
|
|
eventDetails = JSON.parse(logMessage.slice(startDetailsStr.length));
|
|
} catch {
|
|
let jsonString = logMessage.slice(startDetailsStr.length);
|
|
|
|
jsonString = insertQuotesAroundField(jsonString, 'maker');
|
|
jsonString = insertQuotesAroundField(jsonString, 'taker');
|
|
jsonString = insertQuotesAroundField(jsonString, 'taker_side');
|
|
jsonString = insertQuotesAroundField(jsonString, 'maker_order_id');
|
|
jsonString = insertQuotesAroundField(jsonString, 'taker_order_id');
|
|
|
|
eventDetails = JSON.parse(jsonString);
|
|
}
|
|
|
|
events.push({
|
|
event_num: eventNum,
|
|
maker: eventDetails['maker'],
|
|
maker_fee: eventDetails['maker_fee'],
|
|
maker_order_id: eventDetails['maker_order_id'],
|
|
|
|
// Storing both price and quantity in UI terms to be consistent with db
|
|
price: eventDetails['price'] / lotSizes.quoteLotSize,
|
|
quantity: eventDetails['quantity'] * lotSizes.baseLotSize / Math.pow(10, perpMarket.baseDecimals),
|
|
|
|
seq_num: eventDetails['seq_num'],
|
|
taker: eventDetails['taker'],
|
|
taker_fee: eventDetails['taker_fee'],
|
|
taker_order_id: eventDetails['taker_order_id'],
|
|
taker_side: eventDetails['taker_side'],
|
|
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
|
|
perp_market: perpMarket.name,
|
|
base_symbol: perpMarket.baseSymbol
|
|
});
|
|
|
|
eventNum++;
|
|
}
|
|
}
|
|
|
|
return events;
|
|
}
|
|
|
|
function parseResolvePerpBankruptcy(
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
let mangoGroupPk = accounts[0];
|
|
let liqee = accounts[2];
|
|
let liqor = accounts[3];
|
|
|
|
let perpMarkets = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'perpMarkets'
|
|
];
|
|
let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'quoteSymbol'
|
|
];
|
|
let quoteDecimals = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroupPk)
|
|
['tokens'].find((e) => e.symbol === quoteSymbol).decimals;
|
|
|
|
// Either bankruptcy or socialized loss (or both) will be logged
|
|
// So initialize variables as null - nulls can be outputted to json if variables are not set
|
|
let perpMarketName;
|
|
let insuranceFundTransfer: number | null = null;
|
|
let loss: number | null = null;
|
|
|
|
// TODO: validate this when an example comes along
|
|
let startDetailsStr = 'Program log: perp_bankruptcy details: ';
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let bankruptcyDetails = JSON.parse(
|
|
logMessage.slice(startDetailsStr.length),
|
|
);
|
|
|
|
let perpMarket = perpMarkets.find(
|
|
(e) => e['marketIndex'] === bankruptcyDetails['liab_index'],
|
|
);
|
|
perpMarketName = perpMarket.name;
|
|
|
|
insuranceFundTransfer =
|
|
bankruptcyDetails['insurance_transfer'] / Math.pow(10, quoteDecimals);
|
|
}
|
|
}
|
|
|
|
startDetailsStr = 'Program log: perp_socialized_loss details: ';
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let socializedLossDetails = JSON.parse(
|
|
logMessage.slice(startDetailsStr.length),
|
|
);
|
|
|
|
let perpMarket = perpMarkets.find(
|
|
(e) => e['marketIndex'] === socializedLossDetails['liab_index'],
|
|
);
|
|
perpMarketName = perpMarket.name;
|
|
|
|
// loss is on quote position
|
|
loss =
|
|
socializedLossDetails['socialized_loss'] / Math.pow(10, quoteDecimals);
|
|
}
|
|
}
|
|
|
|
return [
|
|
{
|
|
liqor: liqor,
|
|
liqee: liqee,
|
|
perp_market_name: perpMarketName,
|
|
insurance_fund_transfer: insuranceFundTransfer,
|
|
loss: loss,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseResolveTokenBankruptcy(
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
let mangoGroupPk = accounts[0];
|
|
let liqee = accounts[2];
|
|
let liqor = accounts[3];
|
|
|
|
let tokens = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'tokens'
|
|
];
|
|
let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'quoteSymbol'
|
|
];
|
|
let quoteDecimals = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroupPk)
|
|
['tokens'].find((e) => e.symbol === quoteSymbol).decimals;
|
|
|
|
// Either bankruptcy or socialized loss (or both) will be logged
|
|
// So initialize variables as null - nulls can be outputted to json if variables are not set
|
|
let symbol;
|
|
let insuranceFundTransfer: number | null = null;
|
|
let loss: number | null = null;
|
|
let percentageLoss: number | null = null;
|
|
let depositIndex: number | null = null;
|
|
|
|
// TODO: validate this when an example comes along
|
|
let startDetailsStr = 'Program log: token_bankruptcy details: ';
|
|
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let bankruptcyDetails = JSON.parse(
|
|
logMessage.slice(startDetailsStr.length),
|
|
);
|
|
|
|
let tokenIndex = bankruptcyDetails['liab_index'];
|
|
let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
|
|
let token = tokens.find((e) => e['mintKey'] === tokenPk);
|
|
symbol = token.symbol;
|
|
|
|
insuranceFundTransfer =
|
|
bankruptcyDetails['insurance_transfer'] / Math.pow(10, quoteDecimals);
|
|
}
|
|
}
|
|
|
|
startDetailsStr = 'Program log: token_socialized_loss details: ';
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let socializedLossDetails = JSON.parse(
|
|
logMessage.slice(startDetailsStr.length),
|
|
);
|
|
|
|
let tokenIndex = socializedLossDetails['liab_index'];
|
|
let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
|
|
let token = tokens.find((e) => e['mintKey'] === tokenPk);
|
|
symbol = token.symbol;
|
|
|
|
loss =
|
|
socializedLossDetails['native_loss'] / Math.pow(10, token.decimals);
|
|
percentageLoss = socializedLossDetails['percentage_loss'];
|
|
|
|
// Deposit index was added to the logging after launch
|
|
// TODO: remove when we've parsed the logs without deposit_index
|
|
// TODO: does this need to be parsed from native units?
|
|
try {
|
|
depositIndex = socializedLossDetails['deposit_index'];
|
|
} catch {
|
|
// pass
|
|
}
|
|
}
|
|
}
|
|
|
|
return [
|
|
{
|
|
liqor: liqor,
|
|
liqee: liqee,
|
|
symbol: symbol,
|
|
insurance_fund_transfer: insuranceFundTransfer,
|
|
loss: loss,
|
|
percentage_loss: percentageLoss,
|
|
deposit_index: depositIndex,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseLiquidatePerpMarket(
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
if (logMessages.includes('Program log: Account init_health above zero.')) {
|
|
return [];
|
|
}
|
|
|
|
let mangoGroupPk = accounts[0];
|
|
let liqee = accounts[4];
|
|
let liqor = accounts[5];
|
|
|
|
let perpMarkets = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'perpMarkets'
|
|
];
|
|
let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'quoteSymbol'
|
|
];
|
|
|
|
let perpMarketName;
|
|
let liabSymbol;
|
|
let assetSymbol;
|
|
let baseTransfer;
|
|
let quoteTransfer;
|
|
let bankruptcy;
|
|
let startDetailsStr = 'Program log: liquidate_perp_market details: ';
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let liquidationDetails = JSON.parse(
|
|
logMessage.slice(startDetailsStr.length),
|
|
);
|
|
|
|
let perpMarket = perpMarkets.find(
|
|
(e) => e['marketIndex'] === liquidationDetails['market_index'],
|
|
);
|
|
perpMarketName = perpMarket.name;
|
|
let liabDecimals = perpMarket.baseDecimals;
|
|
let assetDecimals = perpMarket.quoteDecimals;
|
|
|
|
liabSymbol = perpMarket.baseSymbol;
|
|
assetSymbol = quoteSymbol;
|
|
baseTransfer =
|
|
liquidationDetails['base_transfer'] / Math.pow(10, liabDecimals);
|
|
// TODO: quoteTransfer is -base_transfer * pmi.base_lot_size - but I don't really know what this means
|
|
quoteTransfer =
|
|
liquidationDetails['quote_transfer'] / Math.pow(10, assetDecimals);
|
|
bankruptcy = liquidationDetails['bankruptcy'];
|
|
}
|
|
}
|
|
|
|
return [
|
|
{
|
|
liqor: liqor,
|
|
liqee: liqee,
|
|
perp_market: perpMarketName,
|
|
liab_symbol: liabSymbol,
|
|
liab_amount: baseTransfer,
|
|
asset_symbol: assetSymbol,
|
|
asset_amount: quoteTransfer,
|
|
bankruptcy: bankruptcy,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseLiquidateTokenAndPerp(
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
if (logMessages.includes('Program log: Account init_health above zero.')) {
|
|
return [];
|
|
}
|
|
|
|
let mangoGroupPk = accounts[0];
|
|
let liqee = accounts[2];
|
|
let liqor = accounts[3];
|
|
|
|
let tokens = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'tokens'
|
|
];
|
|
let perpMarkets = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'perpMarkets'
|
|
];
|
|
|
|
let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'quoteSymbol'
|
|
];
|
|
let quoteDecimals = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroupPk)
|
|
['tokens'].find((e) => e.symbol === quoteSymbol).decimals;
|
|
|
|
let perpMarket;
|
|
let assetSymbol;
|
|
let liabSymbol;
|
|
let assetType;
|
|
let liabType;
|
|
let assetTransfer;
|
|
let assetPrice;
|
|
let liabTransfer;
|
|
let liabPrice;
|
|
let startDetailsStr = 'Program log: liquidate_token_and_perp details: ';
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let liquidationDetails = JSON.parse(
|
|
logMessage.slice(startDetailsStr.length),
|
|
);
|
|
|
|
assetType = liquidationDetails['asset_type'];
|
|
let assetIndex = liquidationDetails['asset_index'];
|
|
|
|
liabType = liquidationDetails['liab_type'];
|
|
let liabIndex = liquidationDetails['liab_index'];
|
|
|
|
let assetDecimals;
|
|
let liabDecimals;
|
|
if (assetType === 'Token') {
|
|
// asset is token and liab is perp
|
|
let assetTokenPk = tokenIndexesMap[mangoGroupPk][assetIndex];
|
|
let assetToken = tokens.find((e) => e['mintKey'] === assetTokenPk);
|
|
assetSymbol = assetToken.symbol;
|
|
assetDecimals = assetToken.decimals;
|
|
|
|
let liabPerpMarket = perpMarkets.find(
|
|
(e) => e['marketIndex'] === liabIndex,
|
|
);
|
|
// Liquidation can only occur on quote position on perp side
|
|
// So I'll set the asset symbol to the quote symbol (as that is what is transferred)
|
|
liabSymbol = quoteSymbol;
|
|
liabDecimals = liabPerpMarket.quoteDecimals;
|
|
perpMarket = liabPerpMarket.name;
|
|
} else {
|
|
// asset is perp and liab is token
|
|
let assetPerpMarket = perpMarkets.find(
|
|
(e) => e['marketIndex'] === assetIndex,
|
|
);
|
|
// Liquidation can only occur on quote position on perp side
|
|
// So I'll set the asset symbol to the quote symbol (as that is what is transferred)
|
|
assetSymbol = quoteSymbol;
|
|
assetDecimals = assetPerpMarket.quoteDecimals;
|
|
perpMarket = assetPerpMarket.name;
|
|
|
|
let liabTokenPk = tokenIndexesMap[mangoGroupPk][liabIndex];
|
|
let liabToken = tokens.find((e) => e['mintKey'] === liabTokenPk);
|
|
liabSymbol = liabToken.symbol;
|
|
liabDecimals = liabToken.decimals;
|
|
}
|
|
|
|
assetTransfer =
|
|
liquidationDetails['asset_transfer'] / Math.pow(10, assetDecimals);
|
|
assetPrice =
|
|
liquidationDetails['asset_price'] *
|
|
Math.pow(10, assetDecimals - quoteDecimals);
|
|
|
|
liabTransfer =
|
|
liquidationDetails['actual_liab_transfer'] / Math.pow(10, liabDecimals);
|
|
liabPrice =
|
|
liquidationDetails['liab_price'] *
|
|
Math.pow(10, liabDecimals - quoteDecimals);
|
|
}
|
|
}
|
|
|
|
return [
|
|
{
|
|
liqor: liqor,
|
|
liqee: liqee,
|
|
perp_market: perpMarket,
|
|
liab_symbol: liabSymbol,
|
|
liab_amount: liabTransfer,
|
|
liab_price: liabPrice,
|
|
liab_type: liabType,
|
|
asset_symbol: assetSymbol,
|
|
asset_amount: assetTransfer,
|
|
asset_price: assetPrice,
|
|
asset_type: assetType,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseLiquidateTokenAndToken(
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
if (logMessages.includes('Program log: Account init_health above zero.')) {
|
|
return [];
|
|
}
|
|
|
|
let mangoGroup = accounts[0];
|
|
let liqee = accounts[2];
|
|
let liqor = accounts[3];
|
|
let assetRootPk = accounts[5];
|
|
let liabRootPk = accounts[7];
|
|
|
|
let assetToken = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroup)
|
|
['tokens'].find((e) => e.rootKey === assetRootPk);
|
|
let liabToken = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroup)
|
|
['tokens'].find((e) => e.rootKey === liabRootPk);
|
|
|
|
let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroup)[
|
|
'quoteSymbol'
|
|
];
|
|
let quoteDecimals = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroup)
|
|
['tokens'].find((e) => e.symbol === quoteSymbol).decimals;
|
|
|
|
let assetPrice;
|
|
let liabPrice;
|
|
let assetTransfer;
|
|
let liabTransfer;
|
|
let bankruptcy;
|
|
let startDetailsStr = 'Program log: liquidate_token_and_token details: ';
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
let liquidationDetails = JSON.parse(
|
|
logMessage.slice(startDetailsStr.length),
|
|
);
|
|
|
|
assetPrice =
|
|
liquidationDetails['asset_price'] *
|
|
Math.pow(10, assetToken.decimals - quoteDecimals);
|
|
liabPrice =
|
|
liquidationDetails['liab_price'] *
|
|
Math.pow(10, liabToken.decimals - quoteDecimals);
|
|
|
|
assetTransfer =
|
|
liquidationDetails['asset_transfer'] /
|
|
Math.pow(10, assetToken.decimals);
|
|
liabTransfer =
|
|
liquidationDetails['liab_transfer'] / Math.pow(10, liabToken.decimals);
|
|
|
|
bankruptcy = liquidationDetails['bankruptcy'];
|
|
}
|
|
}
|
|
|
|
return [
|
|
{
|
|
liqor: liqor,
|
|
liqee: liqee,
|
|
liab_symbol: liabToken.symbol,
|
|
liab_amount: liabTransfer,
|
|
liab_price: liabPrice,
|
|
asset_symbol: assetToken.symbol,
|
|
asset_amount: assetTransfer,
|
|
asset_price: assetPrice,
|
|
bankruptcy: bankruptcy,
|
|
mango_group: mangoGroup,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseRedeemMngo(
|
|
instruction,
|
|
innerInstructions,
|
|
instructionNum,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
let mangoGroup = instruction.accounts[0];
|
|
let marginAccount = instruction.accounts[2];
|
|
|
|
let decimals = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroup)
|
|
['tokens'].find((e) => e.symbol === 'MNGO').decimals;
|
|
|
|
let perpMarket = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroup)
|
|
['perpMarkets'].find(e => e.publicKey === instruction.accounts[4])
|
|
|
|
let perpMarketName = perpMarket.name
|
|
let baseSymbol = perpMarket.baseSymbol
|
|
|
|
// TODO: This would be simpler to just parse logs
|
|
let transferInstruction = innerInstructions.find(
|
|
(e) => e.index === instructionNum - 1,
|
|
).instructions[0];
|
|
|
|
let quantity =
|
|
parseInt(transferInstruction.parsed.info.amount) / Math.pow(10, decimals);
|
|
|
|
return [
|
|
{
|
|
margin_account: marginAccount,
|
|
quantity: quantity,
|
|
instruction_num: instructionNum,
|
|
mango_group: mangoGroup,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
perp_market: perpMarketName,
|
|
base_symbol: baseSymbol
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseDepositWithDraw(
|
|
instruction,
|
|
instructionNum,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
let decodedInstruction = MangoInstructionLayout.decode(
|
|
bs58.decode(instruction.data), 0
|
|
);
|
|
let instructionName = Object.keys(decodedInstruction)[0];
|
|
|
|
let mangoGroup = instruction.accounts[0];
|
|
let marginAccount = instruction.accounts[1];
|
|
let owner = instruction.accounts[2];
|
|
let rootPk = instruction.accounts[4];
|
|
|
|
let token = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroup)
|
|
['tokens'].find((e) => e.rootKey === rootPk);
|
|
let mintDecimals = token.decimals;
|
|
let symbol = token.symbol;
|
|
|
|
let quantity =
|
|
decodedInstruction[instructionName].quantity.toNumber() /
|
|
Math.pow(10, mintDecimals);
|
|
|
|
return [
|
|
{
|
|
margin_account: marginAccount,
|
|
owner: owner,
|
|
symbol: symbol,
|
|
side: instructionName,
|
|
quantity: quantity,
|
|
instruction_num: instructionNum,
|
|
mango_group: mangoGroup,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseNetAmounts(
|
|
logMessage,
|
|
mangoGroupPk,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
let tokens = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'tokens'
|
|
];
|
|
let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'quoteSymbol'
|
|
];
|
|
let quoteDecimals = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroupPk)
|
|
['tokens'].find((e) => e.symbol === quoteSymbol).decimals;
|
|
|
|
let startDetailsStr;
|
|
if (logMessage.startsWith('Program log: checked_sub_net details: ')) {
|
|
startDetailsStr = 'Program log: checked_sub_net details: ';
|
|
} else if (logMessage.startsWith('Program log: checked_add_net details: ')) {
|
|
startDetailsStr = 'Program log: checked_add_net details: ';
|
|
} else {
|
|
throw 'Unexpected startDetailsStr';
|
|
}
|
|
|
|
// TODO: fix this in the rust code and remove this workaround
|
|
// The json is missing quotes around the mango_account_pk
|
|
let netAmountDetails;
|
|
try {
|
|
netAmountDetails = JSON.parse(logMessage.slice(startDetailsStr.length));
|
|
} catch {
|
|
let jsonString = logMessage.slice(startDetailsStr.length);
|
|
jsonString = insertQuotesAroundField(jsonString, 'mango_account_pk');
|
|
netAmountDetails = JSON.parse(jsonString);
|
|
}
|
|
|
|
let mangoAccountPk = netAmountDetails['mango_account_pk'];
|
|
let tokenIndex = netAmountDetails['token_index'];
|
|
|
|
let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
|
|
let token = tokens.find((e) => e['mintKey'] === tokenPk);
|
|
let symbol = token.symbol;
|
|
|
|
let deposit =
|
|
netAmountDetails['deposit'] / Math.pow(10, token.decimals - quoteDecimals);
|
|
let borrow =
|
|
netAmountDetails['borrow'] / Math.pow(10, token.decimals - quoteDecimals);
|
|
|
|
return [
|
|
{
|
|
mango_account: mangoAccountPk,
|
|
symbol: symbol,
|
|
deposit: deposit,
|
|
borrow: borrow,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
}
|
|
|
|
function parseCacheRootBanks(
|
|
instructionNum,
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
let mangoGroupPk = accounts[0];
|
|
|
|
let tokens = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'tokens'
|
|
];
|
|
|
|
let cacheIndexes: any = [];
|
|
let startDetailsStr = 'Program log: cache_root_banks details: ';
|
|
let jsons = getJsonStringsFromArray(logMessages, startDetailsStr);
|
|
|
|
// Nothing cached
|
|
if (jsons.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
// TODO: fix this in the rust code and remove this workaround
|
|
// The json is missing a comma before "borrow_indexes"
|
|
let cacheIndexDetails;
|
|
try {
|
|
cacheIndexDetails = JSON.parse(jsons[0]);
|
|
} catch {
|
|
let jsonString = jsons[0];
|
|
let insertPosition = jsonString.search('"borrow_indexes"');
|
|
let fixedJsonString = [
|
|
jsonString.slice(0, insertPosition),
|
|
',',
|
|
jsonString.slice(insertPosition),
|
|
].join('');
|
|
|
|
cacheIndexDetails = JSON.parse(fixedJsonString);
|
|
}
|
|
|
|
let tokenIndexes = cacheIndexDetails['token_indexes'];
|
|
let depositIndexes = cacheIndexDetails['deposit_indexes'];
|
|
let borrowIndexes = cacheIndexDetails['borrow_indexes'];
|
|
|
|
for (let i = 0; i < tokenIndexes.length; i++) {
|
|
let tokenIndex = tokenIndexes[i];
|
|
|
|
let tokenPk = tokenIndexesMap[mangoGroupPk][tokenIndex];
|
|
let token = tokens.find((e) => e['mintKey'] === tokenPk);
|
|
let symbol = token.symbol;
|
|
|
|
let depositIndex = depositIndexes[i];
|
|
let borrowIndex = borrowIndexes[i];
|
|
|
|
cacheIndexes.push({
|
|
symbol: symbol,
|
|
deposit_index: depositIndex,
|
|
borrow_index: borrowIndex,
|
|
instruction_num: instructionNum,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
});
|
|
}
|
|
|
|
return cacheIndexes;
|
|
}
|
|
|
|
function parseCachePrices(
|
|
instructionNum,
|
|
logMessages,
|
|
accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
let mangoGroupPk = accounts[0];
|
|
|
|
let tokens = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'tokens'
|
|
];
|
|
let oracles = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'oracles'
|
|
];
|
|
let quoteSymbol = ids['groups'].find((e) => e['publicKey'] === mangoGroupPk)[
|
|
'quoteSymbol'
|
|
];
|
|
let quoteDecimals = ids['groups']
|
|
.find((e) => e['publicKey'] === mangoGroupPk)
|
|
['tokens'].find((e) => e.symbol === quoteSymbol).decimals;
|
|
|
|
let cachePrices: any = [];
|
|
let startDetailsStr = 'Program log: cache_prices details: ';
|
|
let jsons = getJsonStringsFromArray(logMessages, startDetailsStr);
|
|
let cachePriceDetails = JSON.parse(jsons[0]);
|
|
|
|
let oracleIndexes = cachePriceDetails['oracle_indexes'];
|
|
let oraclePrices = cachePriceDetails['oracle_prices'];
|
|
|
|
for (let [i, oracleIndex] of oracleIndexes.entries()) {
|
|
let oraclePk = oracleIndexesMap[mangoGroupPk][oracleIndex];
|
|
let oracle = oracles.find((e) => e['publicKey'] === oraclePk);
|
|
let symbol = oracle.symbol;
|
|
|
|
let token = tokens.find((e) => e.symbol === symbol);
|
|
let baseDecimals = token.decimals;
|
|
|
|
let rawPrice = oraclePrices[i];
|
|
let price =
|
|
(rawPrice * Math.pow(10, baseDecimals)) / Math.pow(10, quoteDecimals);
|
|
|
|
cachePrices.push({
|
|
symbol: symbol,
|
|
price: price,
|
|
oracle_pk: oraclePk,
|
|
instruction_num: instructionNum,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
});
|
|
}
|
|
|
|
return cachePrices;
|
|
}
|
|
|
|
function extractNetBalances(
|
|
allAccounts,
|
|
logMessages,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
|
|
// Need to know the mango group pk of the transaction for information not tied to instructions
|
|
// Transaction will only have one mango group - so check which one it is by iterating over mango group pks in IDS
|
|
// TODO: add mango group to appropriate log messages and remove this workaround
|
|
let ids = IDS;
|
|
console.log();
|
|
let mangoGroupPk;
|
|
let accountKeys = allAccounts.map(
|
|
(e) => e.pubkey,
|
|
);
|
|
for (let pk of ids.groups.map((e) => e.publicKey)) {
|
|
if (accountKeys.includes(pk)) {
|
|
mangoGroupPk = pk;
|
|
break;
|
|
}
|
|
}
|
|
|
|
let allNetBalances: any = [];
|
|
// Some information is not tied to instructions specifically
|
|
for (let logMessage of logMessages) {
|
|
if (
|
|
logMessage.startsWith('Program log: checked_sub_net details: ') ||
|
|
logMessage.startsWith('Program log: checked_add_net details: ')
|
|
) {
|
|
let parsedNetAmounts = parseNetAmounts(
|
|
logMessage,
|
|
mangoGroupPk,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
);
|
|
allNetBalances.push(...parsedNetAmounts);
|
|
}
|
|
}
|
|
|
|
// Only want to store the latest deposit/borrow amounts per marginAccount/symbol pair for each instruction
|
|
return getLatestObjPerCombination(allNetBalances, ['mango_account','symbol'])
|
|
}
|
|
|
|
function parseUpdateFunding(
|
|
instructionNum: number,
|
|
logMessage: string,
|
|
accounts: string[],
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
const config = new Config(IDS);
|
|
const mangoGroupPk = accounts[0];
|
|
const perpMarketPk = accounts[2];
|
|
|
|
const groupConfig = config.groups.find(
|
|
(g) => g.publicKey.toString() === mangoGroupPk,
|
|
) as GroupConfig;
|
|
const perpMarketConfig = groupConfig.perpMarkets.find(
|
|
(p) => p.publicKey.toString() === perpMarketPk,
|
|
) as PerpMarketConfig;
|
|
const parsed = JSON.parse(logMessage.slice("Program log: ".length));
|
|
if ('long_funding' in parsed && 'short_funding' in parsed) {
|
|
return [
|
|
{
|
|
symbol: perpMarketConfig.baseSymbol,
|
|
long_funding: parsed.long_funding,
|
|
short_funding: parsed.short_funding,
|
|
instruction_num: instructionNum,
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
},
|
|
];
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
function parseForceSettleQuotePositions(
|
|
logMessages: string,
|
|
accounts: string[],
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
|
|
const config = new Config(IDS);
|
|
const mangoGroupPk = accounts[0];
|
|
|
|
const groupConfig = config.groups.find(
|
|
(g) => g.publicKey.toString() === mangoGroupPk,
|
|
) as GroupConfig;
|
|
|
|
let liqee = accounts[2]
|
|
let liqor = accounts[3]
|
|
|
|
let startDetailsStr = 'Program log: force_settle_quote_positions details: ';
|
|
|
|
let instructionNum = 1
|
|
let out: any = []
|
|
for (let logMessage of logMessages) {
|
|
if (logMessage.startsWith(startDetailsStr)) {
|
|
|
|
let forceSettleQuoteDetails;
|
|
try {
|
|
forceSettleQuoteDetails = JSON.parse(logMessage.slice(startDetailsStr.length));
|
|
} catch {
|
|
let jsonString = logMessage.slice(startDetailsStr.length);
|
|
jsonString = insertQuotesAroundField(jsonString, 'liqee');
|
|
jsonString = insertQuotesAroundField(jsonString, 'liqor');
|
|
|
|
jsonString = jsonString.replace(', }', ' }');
|
|
|
|
forceSettleQuoteDetails = JSON.parse(jsonString);
|
|
}
|
|
|
|
for (let [marketIndex, settlement] of forceSettleQuoteDetails['settlements'].entries()) {
|
|
let perpMarketConfig = groupConfig.perpMarkets.find(
|
|
(p) => p.marketIndex === marketIndex,
|
|
) as PerpMarketConfig;
|
|
|
|
if (settlement !== 0) {
|
|
console.log(perpMarketConfig.name)
|
|
|
|
console.log(perpMarketConfig.baseSymbol)
|
|
let settlementUi = settlement / Math.pow(10, perpMarketConfig.quoteDecimals)
|
|
// console.log(perpMarketConfig.quoteDecimals)
|
|
|
|
out.push(...[
|
|
{
|
|
liqee: liqee,
|
|
liqor: liqor,
|
|
|
|
settlement: settlementUi,
|
|
|
|
perp_market_name: perpMarketConfig.name,
|
|
base_symbol: perpMarketConfig.baseSymbol,
|
|
instruction_num: instructionNum,
|
|
|
|
mango_group: mangoGroupPk,
|
|
block_datetime: blockDatetime,
|
|
slot: slot,
|
|
signature: signature,
|
|
blocktime: blockTime,
|
|
}
|
|
])
|
|
|
|
instructionNum++
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return out
|
|
|
|
}
|
|
|
|
function extractUpdateFundings(
|
|
result,
|
|
instructions,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
) {
|
|
const fundingLogs = result.meta.logMessages.filter((line) =>
|
|
line.startsWith('Program log: {"long_funding":'),
|
|
);
|
|
const fundingInstructions = instructions.filter((ix) => {
|
|
return ix.instructionName === 'UpdateFunding';
|
|
});
|
|
|
|
if (fundingLogs.length !== fundingInstructions.length) {
|
|
throw new Error("funding logs don't match length of funding instructions");
|
|
}
|
|
|
|
let out: any = []
|
|
for (let i = 0; i < fundingLogs.length; i++) {
|
|
const ix = fundingInstructions[i];
|
|
const logMessage = fundingLogs[i];
|
|
out.push(
|
|
...parseUpdateFunding(
|
|
ix.instructionNum,
|
|
logMessage,
|
|
ix.accounts,
|
|
signature,
|
|
blockTime,
|
|
slot,
|
|
blockDatetime,
|
|
),
|
|
);
|
|
}
|
|
|
|
return out
|
|
}
|
|
|