removed solray

This commit is contained in:
dd 2021-02-22 18:02:49 -05:00
parent 0d863ef269
commit d531d2eb27
3 changed files with 411 additions and 413 deletions

View File

@ -61,8 +61,7 @@
"@solana/web3.js": "^0.90.0", "@solana/web3.js": "^0.90.0",
"bn.js": "^5.1.2", "bn.js": "^5.1.2",
"buffer-layout": "^1.2.0", "buffer-layout": "^1.2.0",
"borsh": "https://github.com/defactojob/borsh-js#field-mapper", "borsh": "https://github.com/defactojob/borsh-js#field-mapper"
"solray": "git+https://github.com/defactojob/solray"
}, },
"browserslist": [ "browserslist": [
">0.2%", ">0.2%",

View File

@ -25,7 +25,7 @@ import { SRM_DECIMALS, TOKEN_PROGRAM_ID } from '@project-serum/serum/lib/token-i
import { Order } from '@project-serum/serum/lib/market'; import { Order } from '@project-serum/serum/lib/market';
import Wallet from '@project-serum/sol-wallet-adapter'; import Wallet from '@project-serum/sol-wallet-adapter';
import { makeCancelOrderInstruction, makeSettleFundsInstruction } from './instruction'; import { makeCancelOrderInstruction, makeSettleFundsInstruction } from './instruction';
// import { Aggregator } from './schema' import { Aggregator } from './schema'
export class MangoGroup { export class MangoGroup {
publicKey: PublicKey; publicKey: PublicKey;
@ -58,11 +58,11 @@ export class MangoGroup {
connection: Connection, connection: Connection,
): Promise<number[]> { ): Promise<number[]> {
// const aggs = await Promise.all(this.oracles.map((pk) => (Aggregator.loadWithConnection(pk, connection)))) const aggs = await Promise.all(this.oracles.map((pk) => (Aggregator.loadWithConnection(pk, connection))))
// return aggs.map((agg) => (agg.answer.median.toNumber())).concat(1.0) return aggs.map((agg) => (agg.answer.median.toNumber())).concat(1.0)
const oracleAccs = await getMultipleAccounts(connection, this.oracles); // const oracleAccs = await getMultipleAccounts(connection, this.oracles);
return oracleAccs.map((oa) => decodeAggregatorInfo(oa.accountInfo).submissionValue).concat(1.0) // return oracleAccs.map((oa) => decodeAggregatorInfo(oa.accountInfo).submissionValue).concat(1.0)
} }
getMarketIndex(spotMarket: Market): number { getMarketIndex(spotMarket: Market): number {

View File

@ -1,407 +1,406 @@
// import { PublicKey } from "solray" import BN from "bn.js"
// import BN from "bn.js" import { deserialize, serialize } from "borsh"
// import { deserialize, serialize } from "borsh" import { Connection, PublicKey } from '@solana/web3.js';
// import {Connection} from "@solana/web3.js";
//
// // const conn = new Connection("https://devnet.solana.com", 'singleGossip')
// // const conn = new Connection("https://devnet.solana.com", 'singleGossip')
// const MAX_ORACLES = 13
// const MAX_ORACLES = 13
// const boolMapper = {
// const boolMapper = { encode: boolToInt,
// encode: boolToInt, decode: intToBool,
// decode: intToBool, }
const pubkeyMapper = {
encode: (key: PublicKey) => {
// if (key.constructor == PublicKey) {
// // key.
// } else {
// key
// } // }
// // TODO: support either account or public key
// const pubkeyMapper = { return key.toBuffer()
// encode: (key: PublicKey) => { },
// // if (key.constructor == PublicKey) {
// // // key. decode: (buf: Uint8Array) => {
// // } else { return new PublicKey(buf)
// // key },
// // } }
// // TODO: support either account or public key
// return key.toBuffer() // support strings that can be contained in at most 32 bytes
// }, const str32Mapper = {
// encode: (str: String) => {
// decode: (buf: Uint8Array) => { str = str.substr(0, 32).padEnd(32)
// return new PublicKey(buf) return Buffer.from(str, "utf8").slice(0, 32) // truncate at 32 bytes
// }, },
// }
// decode: (bytes: Uint8Array) => {
// // support strings that can be contained in at most 32 bytes return Buffer.from(bytes).toString("utf8").trim()
// const str32Mapper = { },
// encode: (str: String) => { }
// str = str.substr(0, 32).padEnd(32)
// return Buffer.from(str, "utf8").slice(0, 32) // truncate at 32 bytes const u64Date = {
// }, encode: (date: Date) => {
// return new BN(Math.floor(date.getTime() / 1000))
// decode: (bytes: Uint8Array) => { },
// return Buffer.from(bytes).toString("utf8").trim()
// }, decode: (unixtime: BN) => {
// } return new Date(unixtime.toNumber() * 1000)
// },
// const u64Date = { }
// encode: (date: Date) => {
// return new BN(Math.floor(date.getTime() / 1000)) export abstract class Serialization {
// }, public static async loadWithConnection<T>(
// this: { new (data: any): T },
// decode: (unixtime: BN) => { key: PublicKey,
// return new Date(unixtime.toNumber() * 1000) connection: Connection
// }, ): Promise<T> {
// } const info = await connection.getAccountInfo(key)
// if (!info) {
// export abstract class Serialization { throw new Error("account does not exist")
// public static async loadWithConnection<T>( }
return deserialize(schema, this, info.data)
}
// public static async load<T>(
// this: { new (data: any): T }, // this: { new (data: any): T },
// key: PublicKey, // key: PublicKey
// connection: Connection
// ): Promise<T> { // ): Promise<T> {
// const info = await connection.getAccountInfo(key) // const info = await conn.getAccountInfo(key, "recent")
// if (!info) { // if (!info) {
// throw new Error("account does not exist") // throw new Error("account does not exist")
// } // }
// //
// return deserialize(schema, this, info.data) // return deserialize(schema, this, info.data)
// } // }
// // public static async load<T>(
// // this: { new (data: any): T }, public static deserialize<T>(this: { new (data: any): T }, data: Buffer): T {
// // key: PublicKey return deserialize(schema, this, data)
// // ): Promise<T> { }
// // const info = await conn.getAccountInfo(key, "recent")
// // if (!info) { public static serialize<T extends Serialization>(
// // throw new Error("account does not exist") this: { new (data: any): T },
// // } data: object
// // ): Buffer {
// // return deserialize(schema, this, info.data) return new this(data).serialize()
// // } }
//
// public static deserialize<T>(this: { new (data: any): T }, data: Buffer): T { public serialize(): Buffer {
// return deserialize(schema, this, data) let buf = Buffer.from(serialize(schema, this))
if (buf.length == 0) {
throw new Error("serialized buffer is 0. something wrong with schema")
}
return buf
}
// public toJSON(pretty = true) {
// return JSON.stringify(
// this[Serialization.DATA_KEY],
// jsonReplacer,
// pretty ? 2 : 0
// )
// } // }
//
// public static serialize<T extends Serialization>( // public static DATA_KEY = Symbol("DATA")
// this: { new (data: any): T },
// data: object constructor(data) {
// ): Buffer { // this[Serialization.DATA_KEY] = data
// return new this(data).serialize() Object.assign(this, data)
// } }
// }
// public serialize(): Buffer {
// let buf = Buffer.from(serialize(schema, this)) class Submission {
// if (buf.length == 0) { public updatedAt!: BN
// throw new Error("serialized buffer is 0. something wrong with schema") public value!: BN
// } public oracle!: PublicKey
// return buf
// } public static schema = {
// kind: "struct",
// // public toJSON(pretty = true) { fields: [
// // return JSON.stringify( ["updatedAt", "u64"],
// // this[Serialization.DATA_KEY], ["value", "u64"],
// // jsonReplacer, ["oracle", [32], pubkeyMapper],
// // pretty ? 2 : 0 ],
// // ) }
// // }
// constructor(data: any) {
// // public static DATA_KEY = Symbol("DATA") Object.assign(this, data)
// }
// constructor(data) { }
// // this[Serialization.DATA_KEY] = data
// Object.assign(this, data) export interface IAggregatorConfig {
// } decimals: number
// } description: string
// restartDelay: number
// class Submission { rewardAmount: number
// public updatedAt!: BN maxSubmissions: number
// public value!: BN minSubmissions: number
// public oracle!: PublicKey rewardTokenAccount: PublicKey
// }
// public static schema = {
// kind: "struct", export class AggregatorConfig
// fields: [ extends Serialization
// ["updatedAt", "u64"], implements IAggregatorConfig {
// ["value", "u64"], public decimals!: number
// ["oracle", [32], pubkeyMapper], public description!: string
// ], public restartDelay!: number
// } public rewardAmount!: number
// public maxSubmissions!: number
// constructor(data: any) { public minSubmissions!: number
// Object.assign(this, data) public rewardTokenAccount!: PublicKey
// }
// } public static schema = {
// kind: "struct",
// export interface IAggregatorConfig { fields: [
// decimals: number ["description", [32], str32Mapper],
// description: string ["decimals", "u8"],
// restartDelay: number ["restartDelay", "u8"],
// rewardAmount: number ["maxSubmissions", "u8"],
// maxSubmissions: number ["minSubmissions", "u8"],
// minSubmissions: number ["rewardAmount", "u64"],
// rewardTokenAccount: PublicKey ["rewardTokenAccount", [32], pubkeyMapper],
// } ],
// }
// export class AggregatorConfig }
// extends Serialization
// implements IAggregatorConfig { export class Submissions extends Serialization {
// public decimals!: number public isInitialized!: boolean
public submissions!: Submission[]
public static size = 625
public static schema = {
kind: "struct",
fields: [
["isInitialized", "u8", boolMapper],
["submissions", [Submission, MAX_ORACLES]],
],
}
// if not already submitted, and has empty spot
public canSubmit(pk: PublicKey, cfg: AggregatorConfig): boolean {
if (this.hadSubmitted(pk)) {
return false
}
let emptyIndex = this.submissions.findIndex((s) => {
return s.updatedAt.isZero()
})
return emptyIndex > 0 && emptyIndex < cfg.maxSubmissions
}
public hadSubmitted(pk: PublicKey): boolean {
return !!this.submissions.find((s) => {
return s.oracle.equals(pk)
})
}
}
export class Round extends Serialization {
public id!: BN
public createdAt!: BN
public updatedAt!: BN
public static schema = {
kind: "struct",
fields: [
["id", "u64"],
["createdAt", "u64"],
["updatedAt", "u64"],
],
}
}
export class Answer extends Serialization {
public roundID!: BN
public median!: BN
public createdAt!: BN
public updatedAt!: BN
public static schema = {
kind: "struct",
fields: [
["roundID", "u64"],
["median", "u64"],
["createdAt", "u64"],
["updatedAt", "u64"],
],
}
}
export class Aggregator extends Serialization {
public static size = 229
public config!: AggregatorConfig
public roundSubmissions!: PublicKey
public answerSubmissions!: PublicKey
public answer!: Answer
public round!: Round
public static schema = {
kind: "struct",
fields: [
["config", AggregatorConfig],
["isInitialized", "u8", boolMapper],
["owner", [32], pubkeyMapper],
["round", Round],
["roundSubmissions", [32], pubkeyMapper],
["answer", Answer],
["answerSubmissions", [32], pubkeyMapper],
],
}
}
abstract class InstructionSerialization extends Serialization {
public serialize(): Buffer {
return new Instruction({ [this.constructor.name]: this }).serialize()
}
}
export class Initialize extends InstructionSerialization {
// public submitInterval!: number
// public minSubmissionValue!: number
// public maxSubmissionValue!: number
// public submissionDecimals!: number
// /// A short description of what is being reported
// public description!: string // public description!: string
// public restartDelay!: number
// public rewardAmount!: number public static schema = {
// public maxSubmissions!: number kind: "struct",
// public minSubmissions!: number fields: [["config", AggregatorConfig]],
// public rewardTokenAccount!: PublicKey }
}
export class Configure extends InstructionSerialization {
public static schema = {
kind: "struct",
fields: [["config", AggregatorConfig]],
}
}
export class AddOracle extends InstructionSerialization {
public static schema = {
kind: "struct",
fields: [["description", [32], str32Mapper]],
}
}
export class RemoveOracle extends InstructionSerialization {
public static schema = {
kind: "struct",
fields: [],
}
}
export class Withdraw extends InstructionSerialization {
public static schema = {
kind: "struct",
fields: [["faucetOwnerSeed", ["u8"]]],
}
}
export class Submit extends InstructionSerialization {
public static schema = {
kind: "struct",
fields: [
["round_id", "u64"],
["value", "u64"],
],
}
}
export class Instruction extends Serialization {
public enum!: string
public static schema = {
kind: "enum",
field: "enum",
values: [
[Initialize.name, Initialize],
[Configure.name, Configure],
[AddOracle.name, AddOracle],
[RemoveOracle.name, RemoveOracle],
[Submit.name, Submit],
],
}
public constructor(prop: { [key: string]: any }) {
super({})
// deserializer calls the construction with `{ [enum]: value }`, so we need
// to figure out the enum type
// //
// public static schema = { // expect only one key-value (what a retarded interface)
// kind: "struct", for (let key of Object.keys(prop)) {
// fields: [ this.enum = key
// ["description", [32], str32Mapper], this[key] = prop[key]
// ["decimals", "u8"], return
// ["restartDelay", "u8"], }
// ["maxSubmissions", "u8"],
// ["minSubmissions", "u8"], throw new Error("not an expected enum object")
// ["rewardAmount", "u64"], }
// ["rewardTokenAccount", [32], pubkeyMapper],
// ], public get value() {
// } return this[this.enum]
// } }
}
function intToBool(i: number) {
if (i == 0) {
return false
} else {
return true
}
}
function boolToInt(t: boolean) {
if (t) {
return 1
} else {
return 0
}
}
export class Oracle extends Serialization {
public static size = 113
public allowStartRound!: BN
public withdrawable!: BN
public static schema = {
kind: "struct",
fields: [
["description", [32], str32Mapper],
["isInitialized", "u8", boolMapper],
["withdrawable", "u64"],
["allowStartRound", "u64"],
["aggregator", [32], pubkeyMapper],
["owner", [32], pubkeyMapper],
],
}
public canStartNewRound(round: BN): boolean {
return this.allowStartRound.lte(round)
}
}
// if there is optional or variable length items, what is: borsh_utils::get_packed_len::<Submission>()?
// //
// export class Submissions extends Serialization { // would panic given variable sized types
// public isInitialized!: boolean
// public submissions!: Submission[] export const schema = new Map([
// [Aggregator, Aggregator.schema],
// public static size = 625 [Oracle, Oracle.schema],
// public static schema = { [Round, Round.schema],
// kind: "struct", [Answer, Answer.schema],
// fields: [ [AggregatorConfig, AggregatorConfig.schema],
// ["isInitialized", "u8", boolMapper], [Submissions, Submissions.schema],
// ["submissions", [Submission, MAX_ORACLES]], [Submission, Submission.schema],
// ],
// } [Instruction, Instruction.schema],
// [Initialize, Initialize.schema],
// // if not already submitted, and has empty spot [AddOracle, AddOracle.schema],
// public canSubmit(pk: PublicKey, cfg: AggregatorConfig): boolean { [Submit, Submit.schema],
// if (this.hadSubmitted(pk)) {
// return false ] as any) as any
// }
//
// let emptyIndex = this.submissions.findIndex((s) => {
// return s.updatedAt.isZero()
// })
//
// return emptyIndex > 0 && emptyIndex < cfg.maxSubmissions
// }
//
// public hadSubmitted(pk: PublicKey): boolean {
// return !!this.submissions.find((s) => {
// return s.oracle.equals(pk)
// })
// }
// }
//
// export class Round extends Serialization {
// public id!: BN
// public createdAt!: BN
// public updatedAt!: BN
//
// public static schema = {
// kind: "struct",
// fields: [
// ["id", "u64"],
// ["createdAt", "u64"],
// ["updatedAt", "u64"],
// ],
// }
// }
//
// export class Answer extends Serialization {
// public roundID!: BN
// public median!: BN
// public createdAt!: BN
// public updatedAt!: BN
//
// public static schema = {
// kind: "struct",
// fields: [
// ["roundID", "u64"],
// ["median", "u64"],
// ["createdAt", "u64"],
// ["updatedAt", "u64"],
// ],
// }
// }
//
// export class Aggregator extends Serialization {
// public static size = 229
//
// public config!: AggregatorConfig
// public roundSubmissions!: PublicKey
// public answerSubmissions!: PublicKey
// public answer!: Answer
// public round!: Round
//
// public static schema = {
// kind: "struct",
// fields: [
// ["config", AggregatorConfig],
// ["isInitialized", "u8", boolMapper],
// ["owner", [32], pubkeyMapper],
// ["round", Round],
// ["roundSubmissions", [32], pubkeyMapper],
// ["answer", Answer],
// ["answerSubmissions", [32], pubkeyMapper],
// ],
// }
//
//
// }
//
// abstract class InstructionSerialization extends Serialization {
// public serialize(): Buffer {
// return new Instruction({ [this.constructor.name]: this }).serialize()
// }
// }
//
// export class Initialize extends InstructionSerialization {
// // public submitInterval!: number
// // public minSubmissionValue!: number
// // public maxSubmissionValue!: number
// // public submissionDecimals!: number
// // /// A short description of what is being reported
// // public description!: string
//
// public static schema = {
// kind: "struct",
// fields: [["config", AggregatorConfig]],
// }
// }
//
// export class Configure extends InstructionSerialization {
// public static schema = {
// kind: "struct",
// fields: [["config", AggregatorConfig]],
// }
// }
//
// export class AddOracle extends InstructionSerialization {
// public static schema = {
// kind: "struct",
// fields: [["description", [32], str32Mapper]],
// }
// }
//
// export class RemoveOracle extends InstructionSerialization {
// public static schema = {
// kind: "struct",
// fields: [],
// }
// }
//
// export class Withdraw extends InstructionSerialization {
// public static schema = {
// kind: "struct",
// fields: [["faucetOwnerSeed", ["u8"]]],
// }
// }
//
// export class Submit extends InstructionSerialization {
// public static schema = {
// kind: "struct",
// fields: [
// ["round_id", "u64"],
// ["value", "u64"],
// ],
// }
// }
//
// export class Instruction extends Serialization {
// public enum!: string
//
// public static schema = {
// kind: "enum",
// field: "enum",
// values: [
// [Initialize.name, Initialize],
// [Configure.name, Configure],
// [AddOracle.name, AddOracle],
// [RemoveOracle.name, RemoveOracle],
// [Submit.name, Submit],
// ],
// }
//
// public constructor(prop: { [key: string]: any }) {
// super({})
// // deserializer calls the construction with `{ [enum]: value }`, so we need
// // to figure out the enum type
// //
// // expect only one key-value (what a retarded interface)
// for (let key of Object.keys(prop)) {
// this.enum = key
// this[key] = prop[key]
// return
// }
//
// throw new Error("not an expected enum object")
// }
//
// public get value() {
// return this[this.enum]
// }
// }
//
// function intToBool(i: number) {
// if (i == 0) {
// return false
// } else {
// return true
// }
// }
//
// function boolToInt(t: boolean) {
// if (t) {
// return 1
// } else {
// return 0
// }
// }
//
// export class Oracle extends Serialization {
// public static size = 113
// public allowStartRound!: BN
// public withdrawable!: BN
//
// public static schema = {
// kind: "struct",
// fields: [
// ["description", [32], str32Mapper],
// ["isInitialized", "u8", boolMapper],
// ["withdrawable", "u64"],
// ["allowStartRound", "u64"],
// ["aggregator", [32], pubkeyMapper],
// ["owner", [32], pubkeyMapper],
// ],
// }
//
// public canStartNewRound(round: BN): boolean {
// return this.allowStartRound.lte(round)
// }
// }
//
// // if there is optional or variable length items, what is: borsh_utils::get_packed_len::<Submission>()?
// //
// // would panic given variable sized types
//
// export const schema = new Map([
// [Aggregator, Aggregator.schema],
// [Oracle, Oracle.schema],
// [Round, Round.schema],
// [Answer, Answer.schema],
// [AggregatorConfig, AggregatorConfig.schema],
// [Submissions, Submissions.schema],
// [Submission, Submission.schema],
//
// [Instruction, Instruction.schema],
// [Initialize, Initialize.schema],
// [AddOracle, AddOracle.schema],
// [Submit, Submit.schema],
//
// ] as any) as any