@dolomite-exchange/dolomite-margin
Version:
Ethereum Smart Contracts and TypeScript library used for the DolomiteMargin trading protocol
257 lines • 10.5 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Logs = void 0;
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const Helpers_1 = require("../lib/Helpers");
const Events_json_1 = require("../../build/published_contracts/Events.json");
const AdminImpl_json_1 = require("../../build/published_contracts/AdminImpl.json");
const Permission_json_1 = require("../../build/published_contracts/Permission.json");
const Expiry_json_1 = require("../../build/published_contracts/Expiry.json");
const SignedOperationProxy_json_1 = require("../../build/published_contracts/SignedOperationProxy.json");
const EventEmitterRegistry_json_1 = require("../../build/published_contracts/EventEmitterRegistry.json");
class Logs {
constructor(contracts, web3) {
this.contracts = contracts;
this.web3 = web3;
}
parseLogs(receipt, options = {}) {
let logs = this.parseAllLogs(receipt);
if (options.skipAdminLogs) {
logs = logs.filter((log) => !this.logIsFrom(log, AdminImpl_json_1.abi));
}
if (options.skipOperationLogs) {
logs = logs.filter((log) => !this.logIsFrom(log, Events_json_1.abi));
}
if (options.skipPermissionLogs) {
logs = logs.filter((log) => !this.logIsFrom(log, Permission_json_1.abi));
}
if (options.skipSignedOperationProxyLogs) {
logs = logs.filter((log) => !this.logIsFrom(log, SignedOperationProxy_json_1.abi));
}
if (options.skipExpiryLogs) {
logs = logs.filter((log) => !this.logIsFrom(log, Expiry_json_1.abi));
}
if (options.skipEventEmitterRegistry) {
logs = logs.filter((log) => !this.logIsFrom(log, EventEmitterRegistry_json_1.abi));
}
const coveragePrefix = '__';
logs = logs.filter(log => !log.name.startsWith(coveragePrefix));
return logs;
}
logIsFrom(log, abi) {
return abi.filter((e) => e.name === log.name).length !== 0;
}
parseAllLogs(receipt) {
let events;
if (receipt.logs) {
events = JSON.parse(JSON.stringify(receipt.logs));
return events.map(e => this.parseLog(e)).filter(l => !!l);
}
if (receipt.events) {
const tempEvents = JSON.parse(JSON.stringify(receipt.events));
events = [];
Object.values(tempEvents).forEach((e) => {
if (Array.isArray(e)) {
e.forEach(ev => events.push(ev));
}
else {
events.push(e);
}
});
events.sort((a, b) => a.logIndex - b.logIndex);
return events.map(e => this.parseEvent(e)).filter(l => !!l);
}
throw new Error('Receipt has no logs');
}
eventLogToLog(event) {
return {
address: event.address,
data: event.raw.data,
topics: event.raw.topics,
logIndex: event.logIndex,
transactionHash: event.transactionHash,
transactionIndex: event.transactionIndex,
blockHash: event.blockHash,
blockNumber: event.blockNumber,
};
}
parseEvent(event) {
return this.parseLog(this.eventLogToLog(event));
}
parseLog(log) {
switch (log.address.toLowerCase()) {
case this.contracts.dolomiteMargin.options.address.toLowerCase(): {
return this.parseLogWithContract(this.contracts.dolomiteMargin, log);
}
case this.contracts.expiry.options.address.toLowerCase(): {
return this.parseLogWithContract(this.contracts.expiry, log);
}
case this.contracts.signedOperationProxy.options.address.toLowerCase(): {
return this.parseLogWithContract(this.contracts.signedOperationProxy, log);
}
case this.contracts.eventEmitterRegistry.options.address.toLowerCase(): {
return this.parseLogWithContract(this.contracts.eventEmitterRegistry, log);
}
}
return null;
}
parseEventLogWithContract(contract, event) {
return this.parseLogWithContract(contract, this.eventLogToLog(event));
}
parseLogWithContract(contract, log) {
const events = contract.options.jsonInterface.filter((e) => e.type === 'event');
const eventJson = events.find((e) => e.signature.toLowerCase() === log.topics[0].toLowerCase());
if (!eventJson && process.env.COVERAGE !== 'true') {
throw new Error(`Event with topic not found: ${log.topics[0]}`);
}
else if (!eventJson) {
return null;
}
const eventArgs = this.web3.eth.abi.decodeLog(eventJson.inputs, log.data, log.topics.slice(1));
return {
...log,
name: eventJson.name,
args: this.parseArgs(eventJson, eventArgs),
};
}
parseArgs(eventJson, eventArgs) {
const parsed = {};
eventJson.inputs.forEach((input) => {
let val;
if (input.type === 'address') {
val = eventArgs[input.name];
}
else if (input.type === 'bool') {
val = eventArgs[input.name];
}
else if (input.type.match(/^bytes[0-9]*$/)) {
val = eventArgs[input.name];
}
else if (input.type.match(/^uint[0-9]*$/)) {
val = new bignumber_js_1.default(eventArgs[input.name]);
}
else if (input.type.match(/^uint[0-9]*\[]$/)) {
val = eventArgs[input.name].map(arg => new bignumber_js_1.default(arg));
}
else if (input.type === 'tuple') {
val = Logs.parseTuple(input, eventArgs[input.name]);
}
else if (input.type === 'tuple[]') {
val = eventArgs[input.name].map(arg => Logs.parseTuple(input, arg));
}
else if (input.type === 'string') {
val = eventArgs[input.name];
}
else {
throw new Error(`Unknown event arg type ${input.type}`);
}
parsed[input.name] = val;
});
return parsed;
}
static parseTuple(input, eventArgs) {
if (Array.isArray(input.components) &&
input.components.length === 2 &&
input.components[0].name === 'owner' &&
input.components[1].name === 'number') {
return Logs.parseAccountInfo(eventArgs);
}
if (Array.isArray(input.components) &&
input.components.length === 2 &&
input.components[0].name === 'deltaWei' &&
input.components[1].name === 'newPar') {
return Logs.parseBalanceUpdate(eventArgs);
}
if (Array.isArray(input.components) &&
input.components.length === 3 &&
input.components[0].name === 'borrow' &&
input.components[1].name === 'supply' &&
input.components[2].name === 'lastUpdate') {
return Logs.parseIndex(eventArgs);
}
if (Array.isArray(input.components) &&
input.components.length === 1 &&
input.components[0].name === 'value') {
if (input.name.toLowerCase().includes('spread') ||
input.name.toLowerCase().includes('ratio') ||
input.name.toLowerCase().includes('rate') ||
input.name.toLowerCase().includes('premium')) {
return Logs.parseDecimalValue(eventArgs);
}
return Logs.parseIntegerValue(eventArgs);
}
if (Array.isArray(input.components) &&
input.components.length === 2 &&
input.components[0].name === 'sign' &&
input.components[1].name === 'value') {
return Logs.parseWei(eventArgs);
}
if (Array.isArray(input.components) &&
input.components.length === 4 &&
input.components[0].name === 'traderType' &&
input.components[1].name === 'makerAccountIndex' &&
input.components[2].name === 'trader' &&
input.components[3].name === 'tradeData') {
return Logs.parseTraderParam(eventArgs);
}
if (Array.isArray(input.components) &&
input.components.length === 3 &&
input.components[0].name === 'price' &&
input.components[1].name === 'fee' &&
input.components[2].name === 'isNegativeFee') {
return Logs.parseFillData(eventArgs);
}
throw new Error('Unknown tuple type in event');
}
static parseAccountInfo(accountInfo) {
return {
owner: accountInfo.owner,
number: new bignumber_js_1.default(accountInfo.number),
};
}
static parseIndex(index) {
return {
borrow: Helpers_1.stringToDecimal(index.borrow),
supply: Helpers_1.stringToDecimal(index.supply),
lastUpdate: new bignumber_js_1.default(index.lastUpdate),
};
}
static parseBalanceUpdate(update) {
return {
deltaWei: Helpers_1.valueToInteger(update.deltaWei),
newPar: Helpers_1.valueToInteger(update.newPar),
};
}
static parseDecimalValue(value) {
return Helpers_1.stringToDecimal(value.value);
}
static parseIntegerValue(value) {
return new bignumber_js_1.default(value.value);
}
static parseWei(weiData) {
return Helpers_1.valueToInteger({
value: weiData.value,
sign: weiData.sign,
});
}
static parseTraderParam(traderParam) {
return {
traderType: traderParam.traderType,
makerAccountIndex: Helpers_1.stringToDecimal(traderParam.makerAccountIndex).toNumber(),
trader: traderParam.trader,
tradeData: traderParam.tradeData,
};
}
static parseFillData(fillData) {
return {
price: Helpers_1.stringToDecimal(fillData.price),
fee: Helpers_1.stringToDecimal(fillData.fee),
isNegativeFee: fillData.isNegativeFee,
};
}
}
exports.Logs = Logs;
//# sourceMappingURL=Logs.js.map