Created
April 9, 2021 08:25
-
-
Save novaknole/1a6c5f0c7e63b9ba8afd87fc3135ed5d to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. | |
import { | |
ethereum, | |
JSONValue, | |
TypedMap, | |
Entity, | |
Bytes, | |
Address, | |
BigInt | |
} from "@graphprotocol/graph-ts"; | |
export class Challenged extends ethereum.Event { | |
get params(): Challenged__Params { | |
return new Challenged__Params(this); | |
} | |
} | |
export class Challenged__Params { | |
_event: Challenged; | |
constructor(event: Challenged) { | |
this._event = event; | |
} | |
get containerHash(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
get reason(): Bytes { | |
return this._event.parameters[2].value.toBytes(); | |
} | |
get resolverId(): BigInt { | |
return this._event.parameters[3].value.toBigInt(); | |
} | |
get collateral(): ChallengedCollateralStruct { | |
return this._event.parameters[4].value.toTuple() as ChallengedCollateralStruct; | |
} | |
} | |
export class ChallengedCollateralStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class Configured extends ethereum.Event { | |
get params(): Configured__Params { | |
return new Configured__Params(this); | |
} | |
} | |
export class Configured__Params { | |
_event: Configured; | |
constructor(event: Configured) { | |
this._event = event; | |
} | |
get configHash(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
get config(): ConfiguredConfigStruct { | |
return this._event.parameters[2].value.toTuple() as ConfiguredConfigStruct; | |
} | |
} | |
export class ConfiguredConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): ConfiguredConfigScheduleDepositStruct { | |
return this[1].toTuple() as ConfiguredConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): ConfiguredConfigChallengeDepositStruct { | |
return this[2].toTuple() as ConfiguredConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class ConfiguredConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ConfiguredConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class Executed extends ethereum.Event { | |
get params(): Executed__Params { | |
return new Executed__Params(this); | |
} | |
} | |
export class Executed__Params { | |
_event: Executed; | |
constructor(event: Executed) { | |
this._event = event; | |
} | |
get containerHash(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
} | |
export class Frozen extends ethereum.Event { | |
get params(): Frozen__Params { | |
return new Frozen__Params(this); | |
} | |
} | |
export class Frozen__Params { | |
_event: Frozen; | |
constructor(event: Frozen) { | |
this._event = event; | |
} | |
get role(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
} | |
export class Granted extends ethereum.Event { | |
get params(): Granted__Params { | |
return new Granted__Params(this); | |
} | |
} | |
export class Granted__Params { | |
_event: Granted; | |
constructor(event: Granted) { | |
this._event = event; | |
} | |
get role(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
get who(): Address { | |
return this._event.parameters[2].value.toAddress(); | |
} | |
get oracle(): Address { | |
return this._event.parameters[3].value.toAddress(); | |
} | |
} | |
export class Initialized extends ethereum.Event { | |
get params(): Initialized__Params { | |
return new Initialized__Params(this); | |
} | |
} | |
export class Initialized__Params { | |
_event: Initialized; | |
constructor(event: Initialized) { | |
this._event = event; | |
} | |
get key(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
} | |
export class ReceivedCallback extends ethereum.Event { | |
get params(): ReceivedCallback__Params { | |
return new ReceivedCallback__Params(this); | |
} | |
} | |
export class ReceivedCallback__Params { | |
_event: ReceivedCallback; | |
constructor(event: ReceivedCallback) { | |
this._event = event; | |
} | |
get sig(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get data(): Bytes { | |
return this._event.parameters[1].value.toBytes(); | |
} | |
} | |
export class RegisteredCallback extends ethereum.Event { | |
get params(): RegisteredCallback__Params { | |
return new RegisteredCallback__Params(this); | |
} | |
} | |
export class RegisteredCallback__Params { | |
_event: RegisteredCallback; | |
constructor(event: RegisteredCallback) { | |
this._event = event; | |
} | |
get sig(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get magicNumber(): Bytes { | |
return this._event.parameters[1].value.toBytes(); | |
} | |
} | |
export class RegisteredStandard extends ethereum.Event { | |
get params(): RegisteredStandard__Params { | |
return new RegisteredStandard__Params(this); | |
} | |
} | |
export class RegisteredStandard__Params { | |
_event: RegisteredStandard; | |
constructor(event: RegisteredStandard) { | |
this._event = event; | |
} | |
get interfaceId(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
} | |
export class Resolved extends ethereum.Event { | |
get params(): Resolved__Params { | |
return new Resolved__Params(this); | |
} | |
} | |
export class Resolved__Params { | |
_event: Resolved; | |
constructor(event: Resolved) { | |
this._event = event; | |
} | |
get containerHash(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
get approved(): boolean { | |
return this._event.parameters[2].value.toBoolean(); | |
} | |
} | |
export class Revoked extends ethereum.Event { | |
get params(): Revoked__Params { | |
return new Revoked__Params(this); | |
} | |
} | |
export class Revoked__Params { | |
_event: Revoked; | |
constructor(event: Revoked) { | |
this._event = event; | |
} | |
get role(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
get who(): Address { | |
return this._event.parameters[2].value.toAddress(); | |
} | |
} | |
export class Ruled extends ethereum.Event { | |
get params(): Ruled__Params { | |
return new Ruled__Params(this); | |
} | |
} | |
export class Ruled__Params { | |
_event: Ruled; | |
constructor(event: Ruled) { | |
this._event = event; | |
} | |
get arbitrator(): Address { | |
return this._event.parameters[0].value.toAddress(); | |
} | |
get disputeId(): BigInt { | |
return this._event.parameters[1].value.toBigInt(); | |
} | |
get ruling(): BigInt { | |
return this._event.parameters[2].value.toBigInt(); | |
} | |
} | |
export class Scheduled extends ethereum.Event { | |
get params(): Scheduled__Params { | |
return new Scheduled__Params(this); | |
} | |
} | |
export class Scheduled__Params { | |
_event: Scheduled; | |
constructor(event: Scheduled) { | |
this._event = event; | |
} | |
get containerHash(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get payload(): ScheduledPayloadStruct { | |
return this._event.parameters[1].value.toTuple() as ScheduledPayloadStruct; | |
} | |
} | |
export class ScheduledPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array<ScheduledPayloadActionsStruct> { | |
return this[4].toTupleArray<ScheduledPayloadActionsStruct>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class ScheduledPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class Vetoed extends ethereum.Event { | |
get params(): Vetoed__Params { | |
return new Vetoed__Params(this); | |
} | |
} | |
export class Vetoed__Params { | |
_event: Vetoed; | |
constructor(event: Vetoed) { | |
this._event = event; | |
} | |
get containerHash(): Bytes { | |
return this._event.parameters[0].value.toBytes(); | |
} | |
get actor(): Address { | |
return this._event.parameters[1].value.toAddress(); | |
} | |
get reason(): Bytes { | |
return this._event.parameters[2].value.toBytes(); | |
} | |
} | |
export class GovernQueue__challengeInput_containerStruct extends ethereum.Tuple { | |
get payload(): GovernQueue__challengeInput_containerPayloadStruct { | |
return this[0].toTuple() as GovernQueue__challengeInput_containerPayloadStruct; | |
} | |
get config(): GovernQueue__challengeInput_containerConfigStruct { | |
return this[1].toTuple() as GovernQueue__challengeInput_containerConfigStruct; | |
} | |
} | |
export class GovernQueue__challengeInput_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array< | |
GovernQueue__challengeInput_containerPayloadActionsStruct | |
> { | |
return this[4].toTupleArray< | |
GovernQueue__challengeInput_containerPayloadActionsStruct | |
>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class GovernQueue__challengeInput_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class GovernQueue__challengeInput_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): GovernQueue__challengeInput_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as GovernQueue__challengeInput_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): GovernQueue__challengeInput_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as GovernQueue__challengeInput_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class GovernQueue__challengeInput_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__challengeInput_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__configureInput_configStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): GovernQueue__configureInput_configScheduleDepositStruct { | |
return this[1].toTuple() as GovernQueue__configureInput_configScheduleDepositStruct; | |
} | |
get challengeDeposit(): GovernQueue__configureInput_configChallengeDepositStruct { | |
return this[2].toTuple() as GovernQueue__configureInput_configChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class GovernQueue__configureInput_configScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__configureInput_configChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__executeResult { | |
value0: Bytes; | |
value1: Array<Bytes>; | |
constructor(value0: Bytes, value1: Array<Bytes>) { | |
this.value0 = value0; | |
this.value1 = value1; | |
} | |
toMap(): TypedMap<string, ethereum.Value> { | |
let map = new TypedMap<string, ethereum.Value>(); | |
map.set("value0", ethereum.Value.fromFixedBytes(this.value0)); | |
map.set("value1", ethereum.Value.fromBytesArray(this.value1)); | |
return map; | |
} | |
} | |
export class GovernQueue__executeInput_containerStruct extends ethereum.Tuple { | |
get payload(): GovernQueue__executeInput_containerPayloadStruct { | |
return this[0].toTuple() as GovernQueue__executeInput_containerPayloadStruct; | |
} | |
get config(): GovernQueue__executeInput_containerConfigStruct { | |
return this[1].toTuple() as GovernQueue__executeInput_containerConfigStruct; | |
} | |
} | |
export class GovernQueue__executeInput_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array< | |
GovernQueue__executeInput_containerPayloadActionsStruct | |
> { | |
return this[4].toTupleArray< | |
GovernQueue__executeInput_containerPayloadActionsStruct | |
>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class GovernQueue__executeInput_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class GovernQueue__executeInput_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): GovernQueue__executeInput_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as GovernQueue__executeInput_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): GovernQueue__executeInput_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as GovernQueue__executeInput_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class GovernQueue__executeInput_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__executeInput_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__resolveResult { | |
value0: Bytes; | |
value1: Array<Bytes>; | |
constructor(value0: Bytes, value1: Array<Bytes>) { | |
this.value0 = value0; | |
this.value1 = value1; | |
} | |
toMap(): TypedMap<string, ethereum.Value> { | |
let map = new TypedMap<string, ethereum.Value>(); | |
map.set("value0", ethereum.Value.fromFixedBytes(this.value0)); | |
map.set("value1", ethereum.Value.fromBytesArray(this.value1)); | |
return map; | |
} | |
} | |
export class GovernQueue__resolveInput_containerStruct extends ethereum.Tuple { | |
get payload(): GovernQueue__resolveInput_containerPayloadStruct { | |
return this[0].toTuple() as GovernQueue__resolveInput_containerPayloadStruct; | |
} | |
get config(): GovernQueue__resolveInput_containerConfigStruct { | |
return this[1].toTuple() as GovernQueue__resolveInput_containerConfigStruct; | |
} | |
} | |
export class GovernQueue__resolveInput_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array< | |
GovernQueue__resolveInput_containerPayloadActionsStruct | |
> { | |
return this[4].toTupleArray< | |
GovernQueue__resolveInput_containerPayloadActionsStruct | |
>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class GovernQueue__resolveInput_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class GovernQueue__resolveInput_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): GovernQueue__resolveInput_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as GovernQueue__resolveInput_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): GovernQueue__resolveInput_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as GovernQueue__resolveInput_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class GovernQueue__resolveInput_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__resolveInput_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__scheduleInput_containerStruct extends ethereum.Tuple { | |
get payload(): GovernQueue__scheduleInput_containerPayloadStruct { | |
return this[0].toTuple() as GovernQueue__scheduleInput_containerPayloadStruct; | |
} | |
get config(): GovernQueue__scheduleInput_containerConfigStruct { | |
return this[1].toTuple() as GovernQueue__scheduleInput_containerConfigStruct; | |
} | |
} | |
export class GovernQueue__scheduleInput_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array< | |
GovernQueue__scheduleInput_containerPayloadActionsStruct | |
> { | |
return this[4].toTupleArray< | |
GovernQueue__scheduleInput_containerPayloadActionsStruct | |
>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class GovernQueue__scheduleInput_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class GovernQueue__scheduleInput_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): GovernQueue__scheduleInput_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as GovernQueue__scheduleInput_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): GovernQueue__scheduleInput_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as GovernQueue__scheduleInput_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class GovernQueue__scheduleInput_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue__scheduleInput_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class GovernQueue extends ethereum.SmartContract { | |
static bind(address: Address): GovernQueue { | |
return new GovernQueue("GovernQueue", address); | |
} | |
ROOT_ROLE(): Bytes { | |
let result = super.call("ROOT_ROLE", "ROOT_ROLE():(bytes4)", []); | |
return result[0].toBytes(); | |
} | |
try_ROOT_ROLE(): ethereum.CallResult<Bytes> { | |
let result = super.tryCall("ROOT_ROLE", "ROOT_ROLE():(bytes4)", []); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBytes()); | |
} | |
challenge( | |
_container: GovernQueue__challengeInput_containerStruct, | |
_reason: Bytes | |
): BigInt { | |
let result = super.call( | |
"challenge", | |
"challenge(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),bytes):(uint256)", | |
[ethereum.Value.fromTuple(_container), ethereum.Value.fromBytes(_reason)] | |
); | |
return result[0].toBigInt(); | |
} | |
try_challenge( | |
_container: GovernQueue__challengeInput_containerStruct, | |
_reason: Bytes | |
): ethereum.CallResult<BigInt> { | |
let result = super.tryCall( | |
"challenge", | |
"challenge(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),bytes):(uint256)", | |
[ethereum.Value.fromTuple(_container), ethereum.Value.fromBytes(_reason)] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBigInt()); | |
} | |
challengerCache(param0: Bytes): Address { | |
let result = super.call( | |
"challengerCache", | |
"challengerCache(bytes32):(address)", | |
[ethereum.Value.fromFixedBytes(param0)] | |
); | |
return result[0].toAddress(); | |
} | |
try_challengerCache(param0: Bytes): ethereum.CallResult<Address> { | |
let result = super.tryCall( | |
"challengerCache", | |
"challengerCache(bytes32):(address)", | |
[ethereum.Value.fromFixedBytes(param0)] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toAddress()); | |
} | |
configHash(): Bytes { | |
let result = super.call("configHash", "configHash():(bytes32)", []); | |
return result[0].toBytes(); | |
} | |
try_configHash(): ethereum.CallResult<Bytes> { | |
let result = super.tryCall("configHash", "configHash():(bytes32)", []); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBytes()); | |
} | |
configure(_config: GovernQueue__configureInput_configStruct): Bytes { | |
let result = super.call( | |
"configure", | |
"configure((uint256,(address,uint256),(address,uint256),address,bytes)):(bytes32)", | |
[ethereum.Value.fromTuple(_config)] | |
); | |
return result[0].toBytes(); | |
} | |
try_configure( | |
_config: GovernQueue__configureInput_configStruct | |
): ethereum.CallResult<Bytes> { | |
let result = super.tryCall( | |
"configure", | |
"configure((uint256,(address,uint256),(address,uint256),address,bytes)):(bytes32)", | |
[ethereum.Value.fromTuple(_config)] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBytes()); | |
} | |
disputeItemCache(param0: Bytes, param1: Address): BigInt { | |
let result = super.call( | |
"disputeItemCache", | |
"disputeItemCache(bytes32,address):(uint256)", | |
[ | |
ethereum.Value.fromFixedBytes(param0), | |
ethereum.Value.fromAddress(param1) | |
] | |
); | |
return result[0].toBigInt(); | |
} | |
try_disputeItemCache( | |
param0: Bytes, | |
param1: Address | |
): ethereum.CallResult<BigInt> { | |
let result = super.tryCall( | |
"disputeItemCache", | |
"disputeItemCache(bytes32,address):(uint256)", | |
[ | |
ethereum.Value.fromFixedBytes(param0), | |
ethereum.Value.fromAddress(param1) | |
] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBigInt()); | |
} | |
execute( | |
_container: GovernQueue__executeInput_containerStruct | |
): GovernQueue__executeResult { | |
let result = super.call( | |
"execute", | |
"execute(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32,bytes[])", | |
[ethereum.Value.fromTuple(_container)] | |
); | |
return new GovernQueue__executeResult( | |
result[0].toBytes(), | |
result[1].toBytesArray() | |
); | |
} | |
try_execute( | |
_container: GovernQueue__executeInput_containerStruct | |
): ethereum.CallResult<GovernQueue__executeResult> { | |
let result = super.tryCall( | |
"execute", | |
"execute(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32,bytes[])", | |
[ethereum.Value.fromTuple(_container)] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue( | |
new GovernQueue__executeResult( | |
value[0].toBytes(), | |
value[1].toBytesArray() | |
) | |
); | |
} | |
initBlocks(param0: string): BigInt { | |
let result = super.call("initBlocks", "initBlocks(string):(uint256)", [ | |
ethereum.Value.fromString(param0) | |
]); | |
return result[0].toBigInt(); | |
} | |
try_initBlocks(param0: string): ethereum.CallResult<BigInt> { | |
let result = super.tryCall("initBlocks", "initBlocks(string):(uint256)", [ | |
ethereum.Value.fromString(param0) | |
]); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBigInt()); | |
} | |
isFrozen(_role: Bytes): boolean { | |
let result = super.call("isFrozen", "isFrozen(bytes4):(bool)", [ | |
ethereum.Value.fromFixedBytes(_role) | |
]); | |
return result[0].toBoolean(); | |
} | |
try_isFrozen(_role: Bytes): ethereum.CallResult<boolean> { | |
let result = super.tryCall("isFrozen", "isFrozen(bytes4):(bool)", [ | |
ethereum.Value.fromFixedBytes(_role) | |
]); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBoolean()); | |
} | |
nonce(): BigInt { | |
let result = super.call("nonce", "nonce():(uint256)", []); | |
return result[0].toBigInt(); | |
} | |
try_nonce(): ethereum.CallResult<BigInt> { | |
let result = super.tryCall("nonce", "nonce():(uint256)", []); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBigInt()); | |
} | |
queue(param0: Bytes): i32 { | |
let result = super.call("queue", "queue(bytes32):(uint8)", [ | |
ethereum.Value.fromFixedBytes(param0) | |
]); | |
return result[0].toI32(); | |
} | |
try_queue(param0: Bytes): ethereum.CallResult<i32> { | |
let result = super.tryCall("queue", "queue(bytes32):(uint8)", [ | |
ethereum.Value.fromFixedBytes(param0) | |
]); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toI32()); | |
} | |
resolve( | |
_container: GovernQueue__resolveInput_containerStruct, | |
_disputeId: BigInt | |
): GovernQueue__resolveResult { | |
let result = super.call( | |
"resolve", | |
"resolve(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),uint256):(bytes32,bytes[])", | |
[ | |
ethereum.Value.fromTuple(_container), | |
ethereum.Value.fromUnsignedBigInt(_disputeId) | |
] | |
); | |
return new GovernQueue__resolveResult( | |
result[0].toBytes(), | |
result[1].toBytesArray() | |
); | |
} | |
try_resolve( | |
_container: GovernQueue__resolveInput_containerStruct, | |
_disputeId: BigInt | |
): ethereum.CallResult<GovernQueue__resolveResult> { | |
let result = super.tryCall( | |
"resolve", | |
"resolve(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes)),uint256):(bytes32,bytes[])", | |
[ | |
ethereum.Value.fromTuple(_container), | |
ethereum.Value.fromUnsignedBigInt(_disputeId) | |
] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue( | |
new GovernQueue__resolveResult( | |
value[0].toBytes(), | |
value[1].toBytesArray() | |
) | |
); | |
} | |
roles(param0: Bytes, param1: Address): Address { | |
let result = super.call("roles", "roles(bytes4,address):(address)", [ | |
ethereum.Value.fromFixedBytes(param0), | |
ethereum.Value.fromAddress(param1) | |
]); | |
return result[0].toAddress(); | |
} | |
try_roles(param0: Bytes, param1: Address): ethereum.CallResult<Address> { | |
let result = super.tryCall("roles", "roles(bytes4,address):(address)", [ | |
ethereum.Value.fromFixedBytes(param0), | |
ethereum.Value.fromAddress(param1) | |
]); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toAddress()); | |
} | |
schedule(_container: GovernQueue__scheduleInput_containerStruct): Bytes { | |
let result = super.call( | |
"schedule", | |
"schedule(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32)", | |
[ethereum.Value.fromTuple(_container)] | |
); | |
return result[0].toBytes(); | |
} | |
try_schedule( | |
_container: GovernQueue__scheduleInput_containerStruct | |
): ethereum.CallResult<Bytes> { | |
let result = super.tryCall( | |
"schedule", | |
"schedule(((uint256,uint256,address,address,(address,uint256,bytes)[],bytes32,bytes),(uint256,(address,uint256),(address,uint256),address,bytes))):(bytes32)", | |
[ethereum.Value.fromTuple(_container)] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBytes()); | |
} | |
supportsInterface(_interfaceId: Bytes): boolean { | |
let result = super.call( | |
"supportsInterface", | |
"supportsInterface(bytes4):(bool)", | |
[ethereum.Value.fromFixedBytes(_interfaceId)] | |
); | |
return result[0].toBoolean(); | |
} | |
try_supportsInterface(_interfaceId: Bytes): ethereum.CallResult<boolean> { | |
let result = super.tryCall( | |
"supportsInterface", | |
"supportsInterface(bytes4):(bool)", | |
[ethereum.Value.fromFixedBytes(_interfaceId)] | |
); | |
if (result.reverted) { | |
return new ethereum.CallResult(); | |
} | |
let value = result.value; | |
return ethereum.CallResult.fromValue(value[0].toBoolean()); | |
} | |
} | |
export class ConstructorCall extends ethereum.Call { | |
get inputs(): ConstructorCall__Inputs { | |
return new ConstructorCall__Inputs(this); | |
} | |
get outputs(): ConstructorCall__Outputs { | |
return new ConstructorCall__Outputs(this); | |
} | |
} | |
export class ConstructorCall__Inputs { | |
_call: ConstructorCall; | |
constructor(call: ConstructorCall) { | |
this._call = call; | |
} | |
get _aclRoot(): Address { | |
return this._call.inputValues[0].value.toAddress(); | |
} | |
get _initialConfig(): ConstructorCall_initialConfigStruct { | |
return this._call.inputValues[1].value.toTuple() as ConstructorCall_initialConfigStruct; | |
} | |
} | |
export class ConstructorCall__Outputs { | |
_call: ConstructorCall; | |
constructor(call: ConstructorCall) { | |
this._call = call; | |
} | |
} | |
export class ConstructorCall_initialConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): ConstructorCall_initialConfigScheduleDepositStruct { | |
return this[1].toTuple() as ConstructorCall_initialConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): ConstructorCall_initialConfigChallengeDepositStruct { | |
return this[2].toTuple() as ConstructorCall_initialConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class ConstructorCall_initialConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ConstructorCall_initialConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class BulkCall extends ethereum.Call { | |
get inputs(): BulkCall__Inputs { | |
return new BulkCall__Inputs(this); | |
} | |
get outputs(): BulkCall__Outputs { | |
return new BulkCall__Outputs(this); | |
} | |
} | |
export class BulkCall__Inputs { | |
_call: BulkCall; | |
constructor(call: BulkCall) { | |
this._call = call; | |
} | |
get items(): Array<BulkCallItemsStruct> { | |
return this._call.inputValues[0].value.toTupleArray<BulkCallItemsStruct>(); | |
} | |
} | |
export class BulkCall__Outputs { | |
_call: BulkCall; | |
constructor(call: BulkCall) { | |
this._call = call; | |
} | |
} | |
export class BulkCallItemsStruct extends ethereum.Tuple { | |
get op(): i32 { | |
return this[0].toI32(); | |
} | |
get role(): Bytes { | |
return this[1].toBytes(); | |
} | |
get who(): Address { | |
return this[2].toAddress(); | |
} | |
} | |
export class ChallengeCall extends ethereum.Call { | |
get inputs(): ChallengeCall__Inputs { | |
return new ChallengeCall__Inputs(this); | |
} | |
get outputs(): ChallengeCall__Outputs { | |
return new ChallengeCall__Outputs(this); | |
} | |
} | |
export class ChallengeCall__Inputs { | |
_call: ChallengeCall; | |
constructor(call: ChallengeCall) { | |
this._call = call; | |
} | |
get _container(): ChallengeCall_containerStruct { | |
return this._call.inputValues[0].value.toTuple() as ChallengeCall_containerStruct; | |
} | |
get _reason(): Bytes { | |
return this._call.inputValues[1].value.toBytes(); | |
} | |
} | |
export class ChallengeCall__Outputs { | |
_call: ChallengeCall; | |
constructor(call: ChallengeCall) { | |
this._call = call; | |
} | |
get disputeId(): BigInt { | |
return this._call.outputValues[0].value.toBigInt(); | |
} | |
} | |
export class ChallengeCall_containerStruct extends ethereum.Tuple { | |
get payload(): ChallengeCall_containerPayloadStruct { | |
return this[0].toTuple() as ChallengeCall_containerPayloadStruct; | |
} | |
get config(): ChallengeCall_containerConfigStruct { | |
return this[1].toTuple() as ChallengeCall_containerConfigStruct; | |
} | |
} | |
export class ChallengeCall_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array<ChallengeCall_containerPayloadActionsStruct> { | |
return this[4].toTupleArray<ChallengeCall_containerPayloadActionsStruct>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class ChallengeCall_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class ChallengeCall_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): ChallengeCall_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as ChallengeCall_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): ChallengeCall_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as ChallengeCall_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class ChallengeCall_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ChallengeCall_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ConfigureCall extends ethereum.Call { | |
get inputs(): ConfigureCall__Inputs { | |
return new ConfigureCall__Inputs(this); | |
} | |
get outputs(): ConfigureCall__Outputs { | |
return new ConfigureCall__Outputs(this); | |
} | |
} | |
export class ConfigureCall__Inputs { | |
_call: ConfigureCall; | |
constructor(call: ConfigureCall) { | |
this._call = call; | |
} | |
get _config(): ConfigureCall_configStruct { | |
return this._call.inputValues[0].value.toTuple() as ConfigureCall_configStruct; | |
} | |
} | |
export class ConfigureCall__Outputs { | |
_call: ConfigureCall; | |
constructor(call: ConfigureCall) { | |
this._call = call; | |
} | |
get value0(): Bytes { | |
return this._call.outputValues[0].value.toBytes(); | |
} | |
} | |
export class ConfigureCall_configStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): ConfigureCall_configScheduleDepositStruct { | |
return this[1].toTuple() as ConfigureCall_configScheduleDepositStruct; | |
} | |
get challengeDeposit(): ConfigureCall_configChallengeDepositStruct { | |
return this[2].toTuple() as ConfigureCall_configChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class ConfigureCall_configScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ConfigureCall_configChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ExecuteCall extends ethereum.Call { | |
get inputs(): ExecuteCall__Inputs { | |
return new ExecuteCall__Inputs(this); | |
} | |
get outputs(): ExecuteCall__Outputs { | |
return new ExecuteCall__Outputs(this); | |
} | |
} | |
export class ExecuteCall__Inputs { | |
_call: ExecuteCall; | |
constructor(call: ExecuteCall) { | |
this._call = call; | |
} | |
get _container(): ExecuteCall_containerStruct { | |
return this._call.inputValues[0].value.toTuple() as ExecuteCall_containerStruct; | |
} | |
} | |
export class ExecuteCall__Outputs { | |
_call: ExecuteCall; | |
constructor(call: ExecuteCall) { | |
this._call = call; | |
} | |
get failureMap(): Bytes { | |
return this._call.outputValues[0].value.toBytes(); | |
} | |
get value1(): Array<Bytes> { | |
return this._call.outputValues[1].value.toBytesArray(); | |
} | |
} | |
export class ExecuteCall_containerStruct extends ethereum.Tuple { | |
get payload(): ExecuteCall_containerPayloadStruct { | |
return this[0].toTuple() as ExecuteCall_containerPayloadStruct; | |
} | |
get config(): ExecuteCall_containerConfigStruct { | |
return this[1].toTuple() as ExecuteCall_containerConfigStruct; | |
} | |
} | |
export class ExecuteCall_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array<ExecuteCall_containerPayloadActionsStruct> { | |
return this[4].toTupleArray<ExecuteCall_containerPayloadActionsStruct>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class ExecuteCall_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class ExecuteCall_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): ExecuteCall_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as ExecuteCall_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): ExecuteCall_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as ExecuteCall_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class ExecuteCall_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ExecuteCall_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class FreezeCall extends ethereum.Call { | |
get inputs(): FreezeCall__Inputs { | |
return new FreezeCall__Inputs(this); | |
} | |
get outputs(): FreezeCall__Outputs { | |
return new FreezeCall__Outputs(this); | |
} | |
} | |
export class FreezeCall__Inputs { | |
_call: FreezeCall; | |
constructor(call: FreezeCall) { | |
this._call = call; | |
} | |
get _role(): Bytes { | |
return this._call.inputValues[0].value.toBytes(); | |
} | |
} | |
export class FreezeCall__Outputs { | |
_call: FreezeCall; | |
constructor(call: FreezeCall) { | |
this._call = call; | |
} | |
} | |
export class GrantCall extends ethereum.Call { | |
get inputs(): GrantCall__Inputs { | |
return new GrantCall__Inputs(this); | |
} | |
get outputs(): GrantCall__Outputs { | |
return new GrantCall__Outputs(this); | |
} | |
} | |
export class GrantCall__Inputs { | |
_call: GrantCall; | |
constructor(call: GrantCall) { | |
this._call = call; | |
} | |
get _role(): Bytes { | |
return this._call.inputValues[0].value.toBytes(); | |
} | |
get _who(): Address { | |
return this._call.inputValues[1].value.toAddress(); | |
} | |
} | |
export class GrantCall__Outputs { | |
_call: GrantCall; | |
constructor(call: GrantCall) { | |
this._call = call; | |
} | |
} | |
export class GrantWithOracleCall extends ethereum.Call { | |
get inputs(): GrantWithOracleCall__Inputs { | |
return new GrantWithOracleCall__Inputs(this); | |
} | |
get outputs(): GrantWithOracleCall__Outputs { | |
return new GrantWithOracleCall__Outputs(this); | |
} | |
} | |
export class GrantWithOracleCall__Inputs { | |
_call: GrantWithOracleCall; | |
constructor(call: GrantWithOracleCall) { | |
this._call = call; | |
} | |
get _role(): Bytes { | |
return this._call.inputValues[0].value.toBytes(); | |
} | |
get _who(): Address { | |
return this._call.inputValues[1].value.toAddress(); | |
} | |
get _oracle(): Address { | |
return this._call.inputValues[2].value.toAddress(); | |
} | |
} | |
export class GrantWithOracleCall__Outputs { | |
_call: GrantWithOracleCall; | |
constructor(call: GrantWithOracleCall) { | |
this._call = call; | |
} | |
} | |
export class InitializeCall extends ethereum.Call { | |
get inputs(): InitializeCall__Inputs { | |
return new InitializeCall__Inputs(this); | |
} | |
get outputs(): InitializeCall__Outputs { | |
return new InitializeCall__Outputs(this); | |
} | |
} | |
export class InitializeCall__Inputs { | |
_call: InitializeCall; | |
constructor(call: InitializeCall) { | |
this._call = call; | |
} | |
get _aclRoot(): Address { | |
return this._call.inputValues[0].value.toAddress(); | |
} | |
get _initialConfig(): InitializeCall_initialConfigStruct { | |
return this._call.inputValues[1].value.toTuple() as InitializeCall_initialConfigStruct; | |
} | |
} | |
export class InitializeCall__Outputs { | |
_call: InitializeCall; | |
constructor(call: InitializeCall) { | |
this._call = call; | |
} | |
} | |
export class InitializeCall_initialConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): InitializeCall_initialConfigScheduleDepositStruct { | |
return this[1].toTuple() as InitializeCall_initialConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): InitializeCall_initialConfigChallengeDepositStruct { | |
return this[2].toTuple() as InitializeCall_initialConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class InitializeCall_initialConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class InitializeCall_initialConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ResolveCall extends ethereum.Call { | |
get inputs(): ResolveCall__Inputs { | |
return new ResolveCall__Inputs(this); | |
} | |
get outputs(): ResolveCall__Outputs { | |
return new ResolveCall__Outputs(this); | |
} | |
} | |
export class ResolveCall__Inputs { | |
_call: ResolveCall; | |
constructor(call: ResolveCall) { | |
this._call = call; | |
} | |
get _container(): ResolveCall_containerStruct { | |
return this._call.inputValues[0].value.toTuple() as ResolveCall_containerStruct; | |
} | |
get _disputeId(): BigInt { | |
return this._call.inputValues[1].value.toBigInt(); | |
} | |
} | |
export class ResolveCall__Outputs { | |
_call: ResolveCall; | |
constructor(call: ResolveCall) { | |
this._call = call; | |
} | |
get failureMap(): Bytes { | |
return this._call.outputValues[0].value.toBytes(); | |
} | |
get value1(): Array<Bytes> { | |
return this._call.outputValues[1].value.toBytesArray(); | |
} | |
} | |
export class ResolveCall_containerStruct extends ethereum.Tuple { | |
get payload(): ResolveCall_containerPayloadStruct { | |
return this[0].toTuple() as ResolveCall_containerPayloadStruct; | |
} | |
get config(): ResolveCall_containerConfigStruct { | |
return this[1].toTuple() as ResolveCall_containerConfigStruct; | |
} | |
} | |
export class ResolveCall_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array<ResolveCall_containerPayloadActionsStruct> { | |
return this[4].toTupleArray<ResolveCall_containerPayloadActionsStruct>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class ResolveCall_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class ResolveCall_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): ResolveCall_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as ResolveCall_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): ResolveCall_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as ResolveCall_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class ResolveCall_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ResolveCall_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class RevokeCall extends ethereum.Call { | |
get inputs(): RevokeCall__Inputs { | |
return new RevokeCall__Inputs(this); | |
} | |
get outputs(): RevokeCall__Outputs { | |
return new RevokeCall__Outputs(this); | |
} | |
} | |
export class RevokeCall__Inputs { | |
_call: RevokeCall; | |
constructor(call: RevokeCall) { | |
this._call = call; | |
} | |
get _role(): Bytes { | |
return this._call.inputValues[0].value.toBytes(); | |
} | |
get _who(): Address { | |
return this._call.inputValues[1].value.toAddress(); | |
} | |
} | |
export class RevokeCall__Outputs { | |
_call: RevokeCall; | |
constructor(call: RevokeCall) { | |
this._call = call; | |
} | |
} | |
export class ScheduleCall extends ethereum.Call { | |
get inputs(): ScheduleCall__Inputs { | |
return new ScheduleCall__Inputs(this); | |
} | |
get outputs(): ScheduleCall__Outputs { | |
return new ScheduleCall__Outputs(this); | |
} | |
} | |
export class ScheduleCall__Inputs { | |
_call: ScheduleCall; | |
constructor(call: ScheduleCall) { | |
this._call = call; | |
} | |
get _container(): ScheduleCall_containerStruct { | |
return this._call.inputValues[0].value.toTuple() as ScheduleCall_containerStruct; | |
} | |
} | |
export class ScheduleCall__Outputs { | |
_call: ScheduleCall; | |
constructor(call: ScheduleCall) { | |
this._call = call; | |
} | |
get containerHash(): Bytes { | |
return this._call.outputValues[0].value.toBytes(); | |
} | |
} | |
export class ScheduleCall_containerStruct extends ethereum.Tuple { | |
get payload(): ScheduleCall_containerPayloadStruct { | |
return this[0].toTuple() as ScheduleCall_containerPayloadStruct; | |
} | |
get config(): ScheduleCall_containerConfigStruct { | |
return this[1].toTuple() as ScheduleCall_containerConfigStruct; | |
} | |
} | |
export class ScheduleCall_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array<ScheduleCall_containerPayloadActionsStruct> { | |
return this[4].toTupleArray<ScheduleCall_containerPayloadActionsStruct>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class ScheduleCall_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class ScheduleCall_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): ScheduleCall_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as ScheduleCall_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): ScheduleCall_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as ScheduleCall_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class ScheduleCall_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class ScheduleCall_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class VetoCall extends ethereum.Call { | |
get inputs(): VetoCall__Inputs { | |
return new VetoCall__Inputs(this); | |
} | |
get outputs(): VetoCall__Outputs { | |
return new VetoCall__Outputs(this); | |
} | |
} | |
export class VetoCall__Inputs { | |
_call: VetoCall; | |
constructor(call: VetoCall) { | |
this._call = call; | |
} | |
get _container(): VetoCall_containerStruct { | |
return this._call.inputValues[0].value.toTuple() as VetoCall_containerStruct; | |
} | |
get _reason(): Bytes { | |
return this._call.inputValues[1].value.toBytes(); | |
} | |
} | |
export class VetoCall__Outputs { | |
_call: VetoCall; | |
constructor(call: VetoCall) { | |
this._call = call; | |
} | |
} | |
export class VetoCall_containerStruct extends ethereum.Tuple { | |
get payload(): VetoCall_containerPayloadStruct { | |
return this[0].toTuple() as VetoCall_containerPayloadStruct; | |
} | |
get config(): VetoCall_containerConfigStruct { | |
return this[1].toTuple() as VetoCall_containerConfigStruct; | |
} | |
} | |
export class VetoCall_containerPayloadStruct extends ethereum.Tuple { | |
get nonce(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get executionTime(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get submitter(): Address { | |
return this[2].toAddress(); | |
} | |
get executor(): Address { | |
return this[3].toAddress(); | |
} | |
get actions(): Array<VetoCall_containerPayloadActionsStruct> { | |
return this[4].toTupleArray<VetoCall_containerPayloadActionsStruct>(); | |
} | |
get allowFailuresMap(): Bytes { | |
return this[5].toBytes(); | |
} | |
get proof(): Bytes { | |
return this[6].toBytes(); | |
} | |
} | |
export class VetoCall_containerPayloadActionsStruct extends ethereum.Tuple { | |
get to(): Address { | |
return this[0].toAddress(); | |
} | |
get value(): BigInt { | |
return this[1].toBigInt(); | |
} | |
get data(): Bytes { | |
return this[2].toBytes(); | |
} | |
} | |
export class VetoCall_containerConfigStruct extends ethereum.Tuple { | |
get executionDelay(): BigInt { | |
return this[0].toBigInt(); | |
} | |
get scheduleDeposit(): VetoCall_containerConfigScheduleDepositStruct { | |
return this[1].toTuple() as VetoCall_containerConfigScheduleDepositStruct; | |
} | |
get challengeDeposit(): VetoCall_containerConfigChallengeDepositStruct { | |
return this[2].toTuple() as VetoCall_containerConfigChallengeDepositStruct; | |
} | |
get resolver(): Address { | |
return this[3].toAddress(); | |
} | |
get rules(): Bytes { | |
return this[4].toBytes(); | |
} | |
} | |
export class VetoCall_containerConfigScheduleDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} | |
export class VetoCall_containerConfigChallengeDepositStruct extends ethereum.Tuple { | |
get token(): Address { | |
return this[0].toAddress(); | |
} | |
get amount(): BigInt { | |
return this[1].toBigInt(); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment