challengeRPC

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 4, 2019 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const ArbMachineABI = "" /* 482-byte string literal not displayed */

ArbMachineABI is the input ABI used to generate the binding from.

View Source 
const ArbMachineBin = `` /* 1018-byte string literal not displayed */

ArbMachineBin is the compiled bytecode used for deploying new contracts.

View Source 
const ArbProtocolABI = "" /* 5504-byte string literal not displayed */

ArbProtocolABI is the input ABI used to generate the binding from.

View Source 
const ArbProtocolBin = `` /* 17518-byte string literal not displayed */

ArbProtocolBin is the compiled bytecode used for deploying new contracts.

View Source 
const ArbValueABI = "" /* 2084-byte string literal not displayed */

ArbValueABI is the input ABI used to generate the binding from.

View Source 
const ArbValueBin = `` /* 5926-byte string literal not displayed */

ArbValueBin is the compiled bytecode used for deploying new contracts.

View Source 
const BytesLibABI = "[]"

BytesLibABI is the input ABI used to generate the binding from.

View Source 
const BytesLibBin = `` /* 242-byte string literal not displayed */

BytesLibBin is the compiled bytecode used for deploying new contracts.

View Source 
const ChallengeManagerABI = "" /* 4142-byte string literal not displayed */

ChallengeManagerABI is the input ABI used to generate the binding from.

View Source 
const ChallengeManagerBin = `` /* 20122-byte string literal not displayed */

ChallengeManagerBin is the compiled bytecode used for deploying new contracts.

View Source 
const IChallengeManagerABI = "" /* 392-byte string literal not displayed */

IChallengeManagerABI is the input ABI used to generate the binding from.

View Source 
const IChallengeManagerBin = `0x`

IChallengeManagerBin is the compiled bytecode used for deploying new contracts.

View Source 
const IVMTrackerABI = "" /* 294-byte string literal not displayed */

IVMTrackerABI is the input ABI used to generate the binding from.

View Source 
const IVMTrackerBin = `0x`

IVMTrackerBin is the compiled bytecode used for deploying new contracts.

View Source 
const MerkleLibABI = "" /* 800-byte string literal not displayed */

MerkleLibABI is the input ABI used to generate the binding from.

View Source 
const MerkleLibBin = `` /* 2868-byte string literal not displayed */

MerkleLibBin is the compiled bytecode used for deploying new contracts.

View Source 
const OneStepProofABI = "" /* 936-byte string literal not displayed */

OneStepProofABI is the input ABI used to generate the binding from.

View Source 
const OneStepProofBin = `` /* 25894-byte string literal not displayed */

OneStepProofBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type ArbMachine 

type ArbMachine struct {
	ArbMachineCaller     // Read-only binding to the contract
	ArbMachineTransactor // Write-only binding to the contract
	ArbMachineFilterer   // Log filterer for contract events
}

ArbMachine is an auto generated Go binding around an Ethereum contract.

func DeployArbMachine 

func DeployArbMachine(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ArbMachine, error)

DeployArbMachine deploys a new Ethereum contract, binding an instance of ArbMachine to it.

func NewArbMachine 

func NewArbMachine(address common.Address, backend bind.ContractBackend) (*ArbMachine, error)

NewArbMachine creates a new instance of ArbMachine, bound to a specific deployed contract.

type ArbMachineCaller 

type ArbMachineCaller struct {
	// contains filtered or unexported fields
}

ArbMachineCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewArbMachineCaller 

func NewArbMachineCaller(address common.Address, caller bind.ContractCaller) (*ArbMachineCaller, error)

NewArbMachineCaller creates a new read-only instance of ArbMachine, bound to a specific deployed contract.

func (*ArbMachineCaller) MachineHash 

func (_ArbMachine *ArbMachineCaller) MachineHash(opts *bind.CallOpts, instructionStackHash [32]byte, dataStackHash [32]byte, auxStackHash [32]byte, registerHash [32]byte, staticHash [32]byte, errHandlerHash [32]byte) ([32]byte, error)

MachineHash is a free data retrieval call binding the contract method 0xc1355b59.

Solidity: function machineHash(bytes32 instructionStackHash, bytes32 dataStackHash, bytes32 auxStackHash, bytes32 registerHash, bytes32 staticHash, bytes32 errHandlerHash) constant returns(bytes32)

type ArbMachineCallerRaw 

type ArbMachineCallerRaw struct {
	Contract *ArbMachineCaller // Generic read-only contract binding to access the raw methods on
}

ArbMachineCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ArbMachineCallerRaw) Call 

func (_ArbMachine *ArbMachineCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ArbMachineCallerSession 

type ArbMachineCallerSession struct {
	Contract *ArbMachineCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

ArbMachineCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ArbMachineCallerSession) MachineHash 

func (_ArbMachine *ArbMachineCallerSession) MachineHash(instructionStackHash [32]byte, dataStackHash [32]byte, auxStackHash [32]byte, registerHash [32]byte, staticHash [32]byte, errHandlerHash [32]byte) ([32]byte, error)

MachineHash is a free data retrieval call binding the contract method 0xc1355b59.

Solidity: function machineHash(bytes32 instructionStackHash, bytes32 dataStackHash, bytes32 auxStackHash, bytes32 registerHash, bytes32 staticHash, bytes32 errHandlerHash) constant returns(bytes32)

type ArbMachineFilterer 

type ArbMachineFilterer struct {
	// contains filtered or unexported fields
}

ArbMachineFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewArbMachineFilterer 

func NewArbMachineFilterer(address common.Address, filterer bind.ContractFilterer) (*ArbMachineFilterer, error)

NewArbMachineFilterer creates a new log filterer instance of ArbMachine, bound to a specific deployed contract.

type ArbMachineRaw 

type ArbMachineRaw struct {
	Contract *ArbMachine // Generic contract binding to access the raw methods on
}

ArbMachineRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ArbMachineRaw) Call 

func (_ArbMachine *ArbMachineRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ArbMachineRaw) Transact 

func (_ArbMachine *ArbMachineRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ArbMachineRaw) Transfer 

func (_ArbMachine *ArbMachineRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ArbMachineSession 

type ArbMachineSession struct {
	Contract     *ArbMachine       // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ArbMachineSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ArbMachineSession) MachineHash 

func (_ArbMachine *ArbMachineSession) MachineHash(instructionStackHash [32]byte, dataStackHash [32]byte, auxStackHash [32]byte, registerHash [32]byte, staticHash [32]byte, errHandlerHash [32]byte) ([32]byte, error)

MachineHash is a free data retrieval call binding the contract method 0xc1355b59.

Solidity: function machineHash(bytes32 instructionStackHash, bytes32 dataStackHash, bytes32 auxStackHash, bytes32 registerHash, bytes32 staticHash, bytes32 errHandlerHash) constant returns(bytes32)

type ArbMachineTransactor 

type ArbMachineTransactor struct {
	// contains filtered or unexported fields
}

ArbMachineTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewArbMachineTransactor 

func NewArbMachineTransactor(address common.Address, transactor bind.ContractTransactor) (*ArbMachineTransactor, error)

NewArbMachineTransactor creates a new write-only instance of ArbMachine, bound to a specific deployed contract.

type ArbMachineTransactorRaw 

type ArbMachineTransactorRaw struct {
	Contract *ArbMachineTransactor // Generic write-only contract binding to access the raw methods on
}

ArbMachineTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ArbMachineTransactorRaw) Transact 

func (_ArbMachine *ArbMachineTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ArbMachineTransactorRaw) Transfer 

func (_ArbMachine *ArbMachineTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ArbMachineTransactorSession 

type ArbMachineTransactorSession struct {
	Contract     *ArbMachineTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

ArbMachineTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ArbProtocol 

type ArbProtocol struct {
	ArbProtocolCaller     // Read-only binding to the contract
	ArbProtocolTransactor // Write-only binding to the contract
	ArbProtocolFilterer   // Log filterer for contract events
}

ArbProtocol is an auto generated Go binding around an Ethereum contract.

func DeployArbProtocol 

func DeployArbProtocol(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ArbProtocol, error)

DeployArbProtocol deploys a new Ethereum contract, binding an instance of ArbProtocol to it.

func NewArbProtocol 

func NewArbProtocol(address common.Address, backend bind.ContractBackend) (*ArbProtocol, error)

NewArbProtocol creates a new instance of ArbProtocol, bound to a specific deployed contract.

type ArbProtocolCaller 

type ArbProtocolCaller struct {
	// contains filtered or unexported fields
}

ArbProtocolCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewArbProtocolCaller 

func NewArbProtocolCaller(address common.Address, caller bind.ContractCaller) (*ArbProtocolCaller, error)

NewArbProtocolCaller creates a new read-only instance of ArbProtocol, bound to a specific deployed contract.

func (*ArbProtocolCaller) AppendInboxMessages 

func (_ArbProtocol *ArbProtocolCaller) AppendInboxMessages(opts *bind.CallOpts, _inboxHash [32]byte, _pendingMessages [32]byte) ([32]byte, error)

AppendInboxMessages is a free data retrieval call binding the contract method 0xf11fcc26.

Solidity: function appendInboxMessages(bytes32 _inboxHash, bytes32 _pendingMessages) constant returns(bytes32)

func (*ArbProtocolCaller) AppendInboxPendingMessage 

func (_ArbProtocol *ArbProtocolCaller) AppendInboxPendingMessage(opts *bind.CallOpts, _pendingMessages [32]byte, _newMessage [32]byte) ([32]byte, error)

AppendInboxPendingMessage is a free data retrieval call binding the contract method 0xd78d18ea.

Solidity: function appendInboxPendingMessage(bytes32 _pendingMessages, bytes32 _newMessage) constant returns(bytes32)

func (*ArbProtocolCaller) CalculateBeforeValues 

func (_ArbProtocol *ArbProtocolCaller) CalculateBeforeValues(opts *bind.CallOpts, _tokenTypes [][21]byte, _messageTokenNums []uint16, _messageAmounts []*big.Int) ([]*big.Int, error)

CalculateBeforeValues is a free data retrieval call binding the contract method 0x0f89fbff.

Solidity: function calculateBeforeValues(bytes21[] _tokenTypes, uint16[] _messageTokenNums, uint256[] _messageAmounts) constant returns(uint256[])

func (*ArbProtocolCaller) CountSignatures 

func (_ArbProtocol *ArbProtocolCaller) CountSignatures(opts *bind.CallOpts, _signatures []byte) (*big.Int, error)

CountSignatures is a free data retrieval call binding the contract method 0x33ae3ad0.

Solidity: function countSignatures(bytes _signatures) constant returns(uint256)

func (*ArbProtocolCaller) CreateVMHash 

func (_ArbProtocol *ArbProtocolCaller) CreateVMHash(opts *bind.CallOpts, _gracePeriod uint32, _escrowRequired *big.Int, _maxExecutionSteps uint32, _vmState [32]byte, _challengeManagerNum uint16, _assertKeys []common.Address) ([32]byte, error)

CreateVMHash is a free data retrieval call binding the contract method 0xe440673b.

Solidity: function createVMHash(uint32 _gracePeriod, uint128 _escrowRequired, uint32 _maxExecutionSteps, bytes32 _vmState, uint16 _challengeManagerNum, address[] _assertKeys) constant returns(bytes32)

func (*ArbProtocolCaller) GenerateAssertionHash 

func (_ArbProtocol *ArbProtocolCaller) GenerateAssertionHash(opts *bind.CallOpts, _afterHash [32]byte, _numSteps uint32, _firstMessageHash [32]byte, _lastMessageHash [32]byte, _firstLogHash [32]byte, _lastLogHash [32]byte, _totalMessageValueAmounts []*big.Int) ([32]byte, error)

GenerateAssertionHash is a free data retrieval call binding the contract method 0x20903721.

Solidity: function generateAssertionHash(bytes32 _afterHash, uint32 _numSteps, bytes32 _firstMessageHash, bytes32 _lastMessageHash, bytes32 _firstLogHash, bytes32 _lastLogHash, uint256[] _totalMessageValueAmounts) constant returns(bytes32)

func (*ArbProtocolCaller) GenerateLastMessageHash 

func (_ArbProtocol *ArbProtocolCaller) GenerateLastMessageHash(opts *bind.CallOpts, _tokenTypes [][21]byte, _messageData []byte, _messageTokenNum []uint16, _messageAmount []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

GenerateLastMessageHash is a free data retrieval call binding the contract method 0x25200160.

Solidity: function generateLastMessageHash(bytes21[] _tokenTypes, bytes _messageData, uint16[] _messageTokenNum, uint256[] _messageAmount, bytes32[] _messageDestination) constant returns(bytes32)

func (*ArbProtocolCaller) GenerateLastMessageHashStub 

func (_ArbProtocol *ArbProtocolCaller) GenerateLastMessageHashStub(opts *bind.CallOpts, _tokenTypes [][21]byte, _messageDataHashes [][32]byte, _messageTokenNum []uint16, _messageValueAmounts []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

GenerateLastMessageHashStub is a free data retrieval call binding the contract method 0xb3277495.

Solidity: function generateLastMessageHashStub(bytes21[] _tokenTypes, bytes32[] _messageDataHashes, uint16[] _messageTokenNum, uint256[] _messageValueAmounts, bytes32[] _messageDestination) constant returns(bytes32)

func (*ArbProtocolCaller) GenerateMessageStubHash 

func (_ArbProtocol *ArbProtocolCaller) GenerateMessageStubHash(opts *bind.CallOpts, _data [32]byte, _tokenType [21]byte, _value *big.Int, _destination [32]byte) ([32]byte, error)

GenerateMessageStubHash is a free data retrieval call binding the contract method 0xccf69dd7.

Solidity: function generateMessageStubHash(bytes32 _data, bytes21 _tokenType, uint256 _value, bytes32 _destination) constant returns(bytes32)

func (*ArbProtocolCaller) GeneratePreconditionHash 

func (_ArbProtocol *ArbProtocolCaller) GeneratePreconditionHash(opts *bind.CallOpts, _beforeHash [32]byte, _timeBounds [2]uint64, _beforeInbox [32]byte, _tokenTypes [][21]byte, _beforeBalances []*big.Int) ([32]byte, error)

GeneratePreconditionHash is a free data retrieval call binding the contract method 0x3e285598.

Solidity: function generatePreconditionHash(bytes32 _beforeHash, uint64[2] _timeBounds, bytes32 _beforeInbox, bytes21[] _tokenTypes, uint256[] _beforeBalances) constant returns(bytes32)

func (*ArbProtocolCaller) GenerateSentMessageHash 

func (_ArbProtocol *ArbProtocolCaller) GenerateSentMessageHash(opts *bind.CallOpts, _dest [32]byte, _data [32]byte, _tokenType [21]byte, _value *big.Int, _sender [32]byte) ([32]byte, error)

GenerateSentMessageHash is a free data retrieval call binding the contract method 0x2a0500d8.

Solidity: function generateSentMessageHash(bytes32 _dest, bytes32 _data, bytes21 _tokenType, uint256 _value, bytes32 _sender) constant returns(bytes32)

func (*ArbProtocolCaller) ParseSignature 

func (_ArbProtocol *ArbProtocolCaller) ParseSignature(opts *bind.CallOpts, _signatures []byte, _pos *big.Int) (struct {
	V uint8
	R [32]byte
	S [32]byte
}, error)

ParseSignature is a free data retrieval call binding the contract method 0xb31d63cc.

Solidity: function parseSignature(bytes _signatures, uint256 _pos) constant returns(uint8 v, bytes32 r, bytes32 s)

func (*ArbProtocolCaller) RecoverAddresses 

func (_ArbProtocol *ArbProtocolCaller) RecoverAddresses(opts *bind.CallOpts, _messageHash [32]byte, _signatures []byte) ([]common.Address, error)

RecoverAddresses is a free data retrieval call binding the contract method 0xf0c8e969.

Solidity: function recoverAddresses(bytes32 _messageHash, bytes _signatures) constant returns(address[])

func (*ArbProtocolCaller) UnanimousAssertHash 

func (_ArbProtocol *ArbProtocolCaller) UnanimousAssertHash(opts *bind.CallOpts, _fields [5][32]byte, _timeBounds [2]uint64, _tokenTypes [][21]byte, _messageData []byte, _messageTokenNum []uint16, _messageAmount []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

UnanimousAssertHash is a free data retrieval call binding the contract method 0x014bba5b.

Solidity: function unanimousAssertHash(bytes32[5] _fields, uint64[2] _timeBounds, bytes21[] _tokenTypes, bytes _messageData, uint16[] _messageTokenNum, uint256[] _messageAmount, bytes32[] _messageDestination) constant returns(bytes32)

type ArbProtocolCallerRaw 

type ArbProtocolCallerRaw struct {
	Contract *ArbProtocolCaller // Generic read-only contract binding to access the raw methods on
}

ArbProtocolCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ArbProtocolCallerRaw) Call 

func (_ArbProtocol *ArbProtocolCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ArbProtocolCallerSession 

type ArbProtocolCallerSession struct {
	Contract *ArbProtocolCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts      // Call options to use throughout this session
}

ArbProtocolCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ArbProtocolCallerSession) AppendInboxMessages 

func (_ArbProtocol *ArbProtocolCallerSession) AppendInboxMessages(_inboxHash [32]byte, _pendingMessages [32]byte) ([32]byte, error)

AppendInboxMessages is a free data retrieval call binding the contract method 0xf11fcc26.

Solidity: function appendInboxMessages(bytes32 _inboxHash, bytes32 _pendingMessages) constant returns(bytes32)

func (*ArbProtocolCallerSession) AppendInboxPendingMessage 

func (_ArbProtocol *ArbProtocolCallerSession) AppendInboxPendingMessage(_pendingMessages [32]byte, _newMessage [32]byte) ([32]byte, error)

AppendInboxPendingMessage is a free data retrieval call binding the contract method 0xd78d18ea.

Solidity: function appendInboxPendingMessage(bytes32 _pendingMessages, bytes32 _newMessage) constant returns(bytes32)

func (*ArbProtocolCallerSession) CalculateBeforeValues 

func (_ArbProtocol *ArbProtocolCallerSession) CalculateBeforeValues(_tokenTypes [][21]byte, _messageTokenNums []uint16, _messageAmounts []*big.Int) ([]*big.Int, error)

CalculateBeforeValues is a free data retrieval call binding the contract method 0x0f89fbff.

Solidity: function calculateBeforeValues(bytes21[] _tokenTypes, uint16[] _messageTokenNums, uint256[] _messageAmounts) constant returns(uint256[])

func (*ArbProtocolCallerSession) CountSignatures 

func (_ArbProtocol *ArbProtocolCallerSession) CountSignatures(_signatures []byte) (*big.Int, error)

CountSignatures is a free data retrieval call binding the contract method 0x33ae3ad0.

Solidity: function countSignatures(bytes _signatures) constant returns(uint256)

func (*ArbProtocolCallerSession) CreateVMHash 

func (_ArbProtocol *ArbProtocolCallerSession) CreateVMHash(_gracePeriod uint32, _escrowRequired *big.Int, _maxExecutionSteps uint32, _vmState [32]byte, _challengeManagerNum uint16, _assertKeys []common.Address) ([32]byte, error)

CreateVMHash is a free data retrieval call binding the contract method 0xe440673b.

Solidity: function createVMHash(uint32 _gracePeriod, uint128 _escrowRequired, uint32 _maxExecutionSteps, bytes32 _vmState, uint16 _challengeManagerNum, address[] _assertKeys) constant returns(bytes32)

func (*ArbProtocolCallerSession) GenerateAssertionHash 

func (_ArbProtocol *ArbProtocolCallerSession) GenerateAssertionHash(_afterHash [32]byte, _numSteps uint32, _firstMessageHash [32]byte, _lastMessageHash [32]byte, _firstLogHash [32]byte, _lastLogHash [32]byte, _totalMessageValueAmounts []*big.Int) ([32]byte, error)

GenerateAssertionHash is a free data retrieval call binding the contract method 0x20903721.

Solidity: function generateAssertionHash(bytes32 _afterHash, uint32 _numSteps, bytes32 _firstMessageHash, bytes32 _lastMessageHash, bytes32 _firstLogHash, bytes32 _lastLogHash, uint256[] _totalMessageValueAmounts) constant returns(bytes32)

func (*ArbProtocolCallerSession) GenerateLastMessageHash 

func (_ArbProtocol *ArbProtocolCallerSession) GenerateLastMessageHash(_tokenTypes [][21]byte, _messageData []byte, _messageTokenNum []uint16, _messageAmount []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

GenerateLastMessageHash is a free data retrieval call binding the contract method 0x25200160.

Solidity: function generateLastMessageHash(bytes21[] _tokenTypes, bytes _messageData, uint16[] _messageTokenNum, uint256[] _messageAmount, bytes32[] _messageDestination) constant returns(bytes32)

func (*ArbProtocolCallerSession) GenerateLastMessageHashStub 

func (_ArbProtocol *ArbProtocolCallerSession) GenerateLastMessageHashStub(_tokenTypes [][21]byte, _messageDataHashes [][32]byte, _messageTokenNum []uint16, _messageValueAmounts []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

GenerateLastMessageHashStub is a free data retrieval call binding the contract method 0xb3277495.

Solidity: function generateLastMessageHashStub(bytes21[] _tokenTypes, bytes32[] _messageDataHashes, uint16[] _messageTokenNum, uint256[] _messageValueAmounts, bytes32[] _messageDestination) constant returns(bytes32)

func (*ArbProtocolCallerSession) GenerateMessageStubHash 

func (_ArbProtocol *ArbProtocolCallerSession) GenerateMessageStubHash(_data [32]byte, _tokenType [21]byte, _value *big.Int, _destination [32]byte) ([32]byte, error)

GenerateMessageStubHash is a free data retrieval call binding the contract method 0xccf69dd7.

Solidity: function generateMessageStubHash(bytes32 _data, bytes21 _tokenType, uint256 _value, bytes32 _destination) constant returns(bytes32)

func (*ArbProtocolCallerSession) GeneratePreconditionHash 

func (_ArbProtocol *ArbProtocolCallerSession) GeneratePreconditionHash(_beforeHash [32]byte, _timeBounds [2]uint64, _beforeInbox [32]byte, _tokenTypes [][21]byte, _beforeBalances []*big.Int) ([32]byte, error)

GeneratePreconditionHash is a free data retrieval call binding the contract method 0x3e285598.

Solidity: function generatePreconditionHash(bytes32 _beforeHash, uint64[2] _timeBounds, bytes32 _beforeInbox, bytes21[] _tokenTypes, uint256[] _beforeBalances) constant returns(bytes32)

func (*ArbProtocolCallerSession) GenerateSentMessageHash 

func (_ArbProtocol *ArbProtocolCallerSession) GenerateSentMessageHash(_dest [32]byte, _data [32]byte, _tokenType [21]byte, _value *big.Int, _sender [32]byte) ([32]byte, error)

GenerateSentMessageHash is a free data retrieval call binding the contract method 0x2a0500d8.

Solidity: function generateSentMessageHash(bytes32 _dest, bytes32 _data, bytes21 _tokenType, uint256 _value, bytes32 _sender) constant returns(bytes32)

func (*ArbProtocolCallerSession) ParseSignature 

func (_ArbProtocol *ArbProtocolCallerSession) ParseSignature(_signatures []byte, _pos *big.Int) (struct {
	V uint8
	R [32]byte
	S [32]byte
}, error)

ParseSignature is a free data retrieval call binding the contract method 0xb31d63cc.

Solidity: function parseSignature(bytes _signatures, uint256 _pos) constant returns(uint8 v, bytes32 r, bytes32 s)

func (*ArbProtocolCallerSession) RecoverAddresses 

func (_ArbProtocol *ArbProtocolCallerSession) RecoverAddresses(_messageHash [32]byte, _signatures []byte) ([]common.Address, error)

RecoverAddresses is a free data retrieval call binding the contract method 0xf0c8e969.

Solidity: function recoverAddresses(bytes32 _messageHash, bytes _signatures) constant returns(address[])

func (*ArbProtocolCallerSession) UnanimousAssertHash 

func (_ArbProtocol *ArbProtocolCallerSession) UnanimousAssertHash(_fields [5][32]byte, _timeBounds [2]uint64, _tokenTypes [][21]byte, _messageData []byte, _messageTokenNum []uint16, _messageAmount []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

UnanimousAssertHash is a free data retrieval call binding the contract method 0x014bba5b.

Solidity: function unanimousAssertHash(bytes32[5] _fields, uint64[2] _timeBounds, bytes21[] _tokenTypes, bytes _messageData, uint16[] _messageTokenNum, uint256[] _messageAmount, bytes32[] _messageDestination) constant returns(bytes32)

type ArbProtocolFilterer 

type ArbProtocolFilterer struct {
	// contains filtered or unexported fields
}

ArbProtocolFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewArbProtocolFilterer 

func NewArbProtocolFilterer(address common.Address, filterer bind.ContractFilterer) (*ArbProtocolFilterer, error)

NewArbProtocolFilterer creates a new log filterer instance of ArbProtocol, bound to a specific deployed contract.

type ArbProtocolRaw 

type ArbProtocolRaw struct {
	Contract *ArbProtocol // Generic contract binding to access the raw methods on
}

ArbProtocolRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ArbProtocolRaw) Call 

func (_ArbProtocol *ArbProtocolRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ArbProtocolRaw) Transact 

func (_ArbProtocol *ArbProtocolRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ArbProtocolRaw) Transfer 

func (_ArbProtocol *ArbProtocolRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ArbProtocolSession 

type ArbProtocolSession struct {
	Contract     *ArbProtocol      // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ArbProtocolSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ArbProtocolSession) AppendInboxMessages 

func (_ArbProtocol *ArbProtocolSession) AppendInboxMessages(_inboxHash [32]byte, _pendingMessages [32]byte) ([32]byte, error)

AppendInboxMessages is a free data retrieval call binding the contract method 0xf11fcc26.

Solidity: function appendInboxMessages(bytes32 _inboxHash, bytes32 _pendingMessages) constant returns(bytes32)

func (*ArbProtocolSession) AppendInboxPendingMessage 

func (_ArbProtocol *ArbProtocolSession) AppendInboxPendingMessage(_pendingMessages [32]byte, _newMessage [32]byte) ([32]byte, error)

AppendInboxPendingMessage is a free data retrieval call binding the contract method 0xd78d18ea.

Solidity: function appendInboxPendingMessage(bytes32 _pendingMessages, bytes32 _newMessage) constant returns(bytes32)

func (*ArbProtocolSession) CalculateBeforeValues 

func (_ArbProtocol *ArbProtocolSession) CalculateBeforeValues(_tokenTypes [][21]byte, _messageTokenNums []uint16, _messageAmounts []*big.Int) ([]*big.Int, error)

CalculateBeforeValues is a free data retrieval call binding the contract method 0x0f89fbff.

Solidity: function calculateBeforeValues(bytes21[] _tokenTypes, uint16[] _messageTokenNums, uint256[] _messageAmounts) constant returns(uint256[])

func (*ArbProtocolSession) CountSignatures 

func (_ArbProtocol *ArbProtocolSession) CountSignatures(_signatures []byte) (*big.Int, error)

CountSignatures is a free data retrieval call binding the contract method 0x33ae3ad0.

Solidity: function countSignatures(bytes _signatures) constant returns(uint256)

func (*ArbProtocolSession) CreateVMHash 

func (_ArbProtocol *ArbProtocolSession) CreateVMHash(_gracePeriod uint32, _escrowRequired *big.Int, _maxExecutionSteps uint32, _vmState [32]byte, _challengeManagerNum uint16, _assertKeys []common.Address) ([32]byte, error)

CreateVMHash is a free data retrieval call binding the contract method 0xe440673b.

Solidity: function createVMHash(uint32 _gracePeriod, uint128 _escrowRequired, uint32 _maxExecutionSteps, bytes32 _vmState, uint16 _challengeManagerNum, address[] _assertKeys) constant returns(bytes32)

func (*ArbProtocolSession) GenerateAssertionHash 

func (_ArbProtocol *ArbProtocolSession) GenerateAssertionHash(_afterHash [32]byte, _numSteps uint32, _firstMessageHash [32]byte, _lastMessageHash [32]byte, _firstLogHash [32]byte, _lastLogHash [32]byte, _totalMessageValueAmounts []*big.Int) ([32]byte, error)

GenerateAssertionHash is a free data retrieval call binding the contract method 0x20903721.

Solidity: function generateAssertionHash(bytes32 _afterHash, uint32 _numSteps, bytes32 _firstMessageHash, bytes32 _lastMessageHash, bytes32 _firstLogHash, bytes32 _lastLogHash, uint256[] _totalMessageValueAmounts) constant returns(bytes32)

func (*ArbProtocolSession) GenerateLastMessageHash 

func (_ArbProtocol *ArbProtocolSession) GenerateLastMessageHash(_tokenTypes [][21]byte, _messageData []byte, _messageTokenNum []uint16, _messageAmount []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

GenerateLastMessageHash is a free data retrieval call binding the contract method 0x25200160.

Solidity: function generateLastMessageHash(bytes21[] _tokenTypes, bytes _messageData, uint16[] _messageTokenNum, uint256[] _messageAmount, bytes32[] _messageDestination) constant returns(bytes32)

func (*ArbProtocolSession) GenerateLastMessageHashStub 

func (_ArbProtocol *ArbProtocolSession) GenerateLastMessageHashStub(_tokenTypes [][21]byte, _messageDataHashes [][32]byte, _messageTokenNum []uint16, _messageValueAmounts []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

GenerateLastMessageHashStub is a free data retrieval call binding the contract method 0xb3277495.

Solidity: function generateLastMessageHashStub(bytes21[] _tokenTypes, bytes32[] _messageDataHashes, uint16[] _messageTokenNum, uint256[] _messageValueAmounts, bytes32[] _messageDestination) constant returns(bytes32)

func (*ArbProtocolSession) GenerateMessageStubHash 

func (_ArbProtocol *ArbProtocolSession) GenerateMessageStubHash(_data [32]byte, _tokenType [21]byte, _value *big.Int, _destination [32]byte) ([32]byte, error)

GenerateMessageStubHash is a free data retrieval call binding the contract method 0xccf69dd7.

Solidity: function generateMessageStubHash(bytes32 _data, bytes21 _tokenType, uint256 _value, bytes32 _destination) constant returns(bytes32)

func (*ArbProtocolSession) GeneratePreconditionHash 

func (_ArbProtocol *ArbProtocolSession) GeneratePreconditionHash(_beforeHash [32]byte, _timeBounds [2]uint64, _beforeInbox [32]byte, _tokenTypes [][21]byte, _beforeBalances []*big.Int) ([32]byte, error)

GeneratePreconditionHash is a free data retrieval call binding the contract method 0x3e285598.

Solidity: function generatePreconditionHash(bytes32 _beforeHash, uint64[2] _timeBounds, bytes32 _beforeInbox, bytes21[] _tokenTypes, uint256[] _beforeBalances) constant returns(bytes32)

func (*ArbProtocolSession) GenerateSentMessageHash 

func (_ArbProtocol *ArbProtocolSession) GenerateSentMessageHash(_dest [32]byte, _data [32]byte, _tokenType [21]byte, _value *big.Int, _sender [32]byte) ([32]byte, error)

GenerateSentMessageHash is a free data retrieval call binding the contract method 0x2a0500d8.

Solidity: function generateSentMessageHash(bytes32 _dest, bytes32 _data, bytes21 _tokenType, uint256 _value, bytes32 _sender) constant returns(bytes32)

func (*ArbProtocolSession) ParseSignature 

func (_ArbProtocol *ArbProtocolSession) ParseSignature(_signatures []byte, _pos *big.Int) (struct {
	V uint8
	R [32]byte
	S [32]byte
}, error)

ParseSignature is a free data retrieval call binding the contract method 0xb31d63cc.

Solidity: function parseSignature(bytes _signatures, uint256 _pos) constant returns(uint8 v, bytes32 r, bytes32 s)

func (*ArbProtocolSession) RecoverAddresses 

func (_ArbProtocol *ArbProtocolSession) RecoverAddresses(_messageHash [32]byte, _signatures []byte) ([]common.Address, error)

RecoverAddresses is a free data retrieval call binding the contract method 0xf0c8e969.

Solidity: function recoverAddresses(bytes32 _messageHash, bytes _signatures) constant returns(address[])

func (*ArbProtocolSession) UnanimousAssertHash 

func (_ArbProtocol *ArbProtocolSession) UnanimousAssertHash(_fields [5][32]byte, _timeBounds [2]uint64, _tokenTypes [][21]byte, _messageData []byte, _messageTokenNum []uint16, _messageAmount []*big.Int, _messageDestination [][32]byte) ([32]byte, error)

UnanimousAssertHash is a free data retrieval call binding the contract method 0x014bba5b.

Solidity: function unanimousAssertHash(bytes32[5] _fields, uint64[2] _timeBounds, bytes21[] _tokenTypes, bytes _messageData, uint16[] _messageTokenNum, uint256[] _messageAmount, bytes32[] _messageDestination) constant returns(bytes32)

type ArbProtocolTransactor 

type ArbProtocolTransactor struct {
	// contains filtered or unexported fields
}

ArbProtocolTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewArbProtocolTransactor 

func NewArbProtocolTransactor(address common.Address, transactor bind.ContractTransactor) (*ArbProtocolTransactor, error)

NewArbProtocolTransactor creates a new write-only instance of ArbProtocol, bound to a specific deployed contract.

type ArbProtocolTransactorRaw 

type ArbProtocolTransactorRaw struct {
	Contract *ArbProtocolTransactor // Generic write-only contract binding to access the raw methods on
}

ArbProtocolTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ArbProtocolTransactorRaw) Transact 

func (_ArbProtocol *ArbProtocolTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ArbProtocolTransactorRaw) Transfer 

func (_ArbProtocol *ArbProtocolTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ArbProtocolTransactorSession 

type ArbProtocolTransactorSession struct {
	Contract     *ArbProtocolTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
}

ArbProtocolTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ArbValue 

type ArbValue struct {
	ArbValueCaller     // Read-only binding to the contract
	ArbValueTransactor // Write-only binding to the contract
	ArbValueFilterer   // Log filterer for contract events
}

ArbValue is an auto generated Go binding around an Ethereum contract.

func DeployArbValue 

func DeployArbValue(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ArbValue, error)

DeployArbValue deploys a new Ethereum contract, binding an instance of ArbValue to it.

func NewArbValue 

func NewArbValue(address common.Address, backend bind.ContractBackend) (*ArbValue, error)

NewArbValue creates a new instance of ArbValue, bound to a specific deployed contract.

type ArbValueCaller 

type ArbValueCaller struct {
	// contains filtered or unexported fields
}

ArbValueCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewArbValueCaller 

func NewArbValueCaller(address common.Address, caller bind.ContractCaller) (*ArbValueCaller, error)

NewArbValueCaller creates a new read-only instance of ArbValue, bound to a specific deployed contract.

func (*ArbValueCaller) DeserializeValidValueHash 

func (_ArbValue *ArbValueCaller) DeserializeValidValueHash(opts *bind.CallOpts, data []byte, offset *big.Int) (*big.Int, [32]byte, error)

DeserializeValidValueHash is a free data retrieval call binding the contract method 0x615c39b0.

Solidity: function deserialize_valid_value_hash(bytes data, uint256 offset) constant returns(uint256, bytes32)

func (*ArbValueCaller) DeserializeValueHash 

func (_ArbValue *ArbValueCaller) DeserializeValueHash(opts *bind.CallOpts, data []byte) ([32]byte, error)

DeserializeValueHash is a free data retrieval call binding the contract method 0x92516ac7.

Solidity: function deserialize_value_hash(bytes data) constant returns(bytes32)

func (*ArbValueCaller) GetNextValidValue 

func (_ArbValue *ArbValueCaller) GetNextValidValue(opts *bind.CallOpts, data []byte, offset *big.Int) (*big.Int, []byte, error)

GetNextValidValue is a free data retrieval call binding the contract method 0x4d00ef7a.

Solidity: function get_next_valid_value(bytes data, uint256 offset) constant returns(uint256, bytes)

func (*ArbValueCaller) HashCodePointBasicValue 

func (_ArbValue *ArbValueCaller) HashCodePointBasicValue(opts *bind.CallOpts, opcode uint8, nextCodePoint [32]byte) ([32]byte, error)

HashCodePointBasicValue is a free data retrieval call binding the contract method 0x53409fab.

Solidity: function hashCodePointBasicValue(uint8 opcode, bytes32 nextCodePoint) constant returns(bytes32)

func (*ArbValueCaller) HashCodePointImmediateValue 

func (_ArbValue *ArbValueCaller) HashCodePointImmediateValue(opts *bind.CallOpts, opcode uint8, immediateVal [32]byte, nextCodePoint [32]byte) ([32]byte, error)

HashCodePointImmediateValue is a free data retrieval call binding the contract method 0x264f384b.

Solidity: function hashCodePointImmediateValue(uint8 opcode, bytes32 immediateVal, bytes32 nextCodePoint) constant returns(bytes32)

func (*ArbValueCaller) HashEmptyTuple 

func (_ArbValue *ArbValueCaller) HashEmptyTuple(opts *bind.CallOpts) ([32]byte, error)

HashEmptyTuple is a free data retrieval call binding the contract method 0x364df277.

Solidity: function hashEmptyTuple() constant returns(bytes32)

func (*ArbValueCaller) HashIntValue 

func (_ArbValue *ArbValueCaller) HashIntValue(opts *bind.CallOpts, val *big.Int) ([32]byte, error)

HashIntValue is a free data retrieval call binding the contract method 0x1667b411.

Solidity: function hashIntValue(uint256 val) constant returns(bytes32)

func (*ArbValueCaller) IsValidTupleSize 

func (_ArbValue *ArbValueCaller) IsValidTupleSize(opts *bind.CallOpts, size *big.Int) (bool, error)

IsValidTupleSize is a free data retrieval call binding the contract method 0xb2b9dc62.

Solidity: function isValidTupleSize(uint256 size) constant returns(bool)

type ArbValueCallerRaw 

type ArbValueCallerRaw struct {
	Contract *ArbValueCaller // Generic read-only contract binding to access the raw methods on
}

ArbValueCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ArbValueCallerRaw) Call 

func (_ArbValue *ArbValueCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ArbValueCallerSession 

type ArbValueCallerSession struct {
	Contract *ArbValueCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

ArbValueCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ArbValueCallerSession) DeserializeValidValueHash 

func (_ArbValue *ArbValueCallerSession) DeserializeValidValueHash(data []byte, offset *big.Int) (*big.Int, [32]byte, error)

DeserializeValidValueHash is a free data retrieval call binding the contract method 0x615c39b0.

Solidity: function deserialize_valid_value_hash(bytes data, uint256 offset) constant returns(uint256, bytes32)

func (*ArbValueCallerSession) DeserializeValueHash 

func (_ArbValue *ArbValueCallerSession) DeserializeValueHash(data []byte) ([32]byte, error)

DeserializeValueHash is a free data retrieval call binding the contract method 0x92516ac7.

Solidity: function deserialize_value_hash(bytes data) constant returns(bytes32)

func (*ArbValueCallerSession) GetNextValidValue 

func (_ArbValue *ArbValueCallerSession) GetNextValidValue(data []byte, offset *big.Int) (*big.Int, []byte, error)

GetNextValidValue is a free data retrieval call binding the contract method 0x4d00ef7a.

Solidity: function get_next_valid_value(bytes data, uint256 offset) constant returns(uint256, bytes)

func (*ArbValueCallerSession) HashCodePointBasicValue 

func (_ArbValue *ArbValueCallerSession) HashCodePointBasicValue(opcode uint8, nextCodePoint [32]byte) ([32]byte, error)

HashCodePointBasicValue is a free data retrieval call binding the contract method 0x53409fab.

Solidity: function hashCodePointBasicValue(uint8 opcode, bytes32 nextCodePoint) constant returns(bytes32)

func (*ArbValueCallerSession) HashCodePointImmediateValue 

func (_ArbValue *ArbValueCallerSession) HashCodePointImmediateValue(opcode uint8, immediateVal [32]byte, nextCodePoint [32]byte) ([32]byte, error)

HashCodePointImmediateValue is a free data retrieval call binding the contract method 0x264f384b.

Solidity: function hashCodePointImmediateValue(uint8 opcode, bytes32 immediateVal, bytes32 nextCodePoint) constant returns(bytes32)

func (*ArbValueCallerSession) HashEmptyTuple 

func (_ArbValue *ArbValueCallerSession) HashEmptyTuple() ([32]byte, error)

HashEmptyTuple is a free data retrieval call binding the contract method 0x364df277.

Solidity: function hashEmptyTuple() constant returns(bytes32)

func (*ArbValueCallerSession) HashIntValue 

func (_ArbValue *ArbValueCallerSession) HashIntValue(val *big.Int) ([32]byte, error)

HashIntValue is a free data retrieval call binding the contract method 0x1667b411.

Solidity: function hashIntValue(uint256 val) constant returns(bytes32)

func (*ArbValueCallerSession) IsValidTupleSize 

func (_ArbValue *ArbValueCallerSession) IsValidTupleSize(size *big.Int) (bool, error)

IsValidTupleSize is a free data retrieval call binding the contract method 0xb2b9dc62.

Solidity: function isValidTupleSize(uint256 size) constant returns(bool)

type ArbValueFilterer 

type ArbValueFilterer struct {
	// contains filtered or unexported fields
}

ArbValueFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewArbValueFilterer 

func NewArbValueFilterer(address common.Address, filterer bind.ContractFilterer) (*ArbValueFilterer, error)

NewArbValueFilterer creates a new log filterer instance of ArbValue, bound to a specific deployed contract.

type ArbValueRaw 

type ArbValueRaw struct {
	Contract *ArbValue // Generic contract binding to access the raw methods on
}

ArbValueRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ArbValueRaw) Call 

func (_ArbValue *ArbValueRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ArbValueRaw) Transact 

func (_ArbValue *ArbValueRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ArbValueRaw) Transfer 

func (_ArbValue *ArbValueRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ArbValueSession 

type ArbValueSession struct {
	Contract     *ArbValue         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ArbValueSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ArbValueSession) DeserializeValidValueHash 

func (_ArbValue *ArbValueSession) DeserializeValidValueHash(data []byte, offset *big.Int) (*big.Int, [32]byte, error)

DeserializeValidValueHash is a free data retrieval call binding the contract method 0x615c39b0.

Solidity: function deserialize_valid_value_hash(bytes data, uint256 offset) constant returns(uint256, bytes32)

func (*ArbValueSession) DeserializeValueHash 

func (_ArbValue *ArbValueSession) DeserializeValueHash(data []byte) ([32]byte, error)

DeserializeValueHash is a free data retrieval call binding the contract method 0x92516ac7.

Solidity: function deserialize_value_hash(bytes data) constant returns(bytes32)

func (*ArbValueSession) GetNextValidValue 

func (_ArbValue *ArbValueSession) GetNextValidValue(data []byte, offset *big.Int) (*big.Int, []byte, error)

GetNextValidValue is a free data retrieval call binding the contract method 0x4d00ef7a.

Solidity: function get_next_valid_value(bytes data, uint256 offset) constant returns(uint256, bytes)

func (*ArbValueSession) HashCodePointBasicValue 

func (_ArbValue *ArbValueSession) HashCodePointBasicValue(opcode uint8, nextCodePoint [32]byte) ([32]byte, error)

HashCodePointBasicValue is a free data retrieval call binding the contract method 0x53409fab.

Solidity: function hashCodePointBasicValue(uint8 opcode, bytes32 nextCodePoint) constant returns(bytes32)

func (*ArbValueSession) HashCodePointImmediateValue 

func (_ArbValue *ArbValueSession) HashCodePointImmediateValue(opcode uint8, immediateVal [32]byte, nextCodePoint [32]byte) ([32]byte, error)

HashCodePointImmediateValue is a free data retrieval call binding the contract method 0x264f384b.

Solidity: function hashCodePointImmediateValue(uint8 opcode, bytes32 immediateVal, bytes32 nextCodePoint) constant returns(bytes32)

func (*ArbValueSession) HashEmptyTuple 

func (_ArbValue *ArbValueSession) HashEmptyTuple() ([32]byte, error)

HashEmptyTuple is a free data retrieval call binding the contract method 0x364df277.

Solidity: function hashEmptyTuple() constant returns(bytes32)

func (*ArbValueSession) HashIntValue 

func (_ArbValue *ArbValueSession) HashIntValue(val *big.Int) ([32]byte, error)

HashIntValue is a free data retrieval call binding the contract method 0x1667b411.

Solidity: function hashIntValue(uint256 val) constant returns(bytes32)

func (*ArbValueSession) IsValidTupleSize 

func (_ArbValue *ArbValueSession) IsValidTupleSize(size *big.Int) (bool, error)

IsValidTupleSize is a free data retrieval call binding the contract method 0xb2b9dc62.

Solidity: function isValidTupleSize(uint256 size) constant returns(bool)

type ArbValueTransactor 

type ArbValueTransactor struct {
	// contains filtered or unexported fields
}

ArbValueTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewArbValueTransactor 

func NewArbValueTransactor(address common.Address, transactor bind.ContractTransactor) (*ArbValueTransactor, error)

NewArbValueTransactor creates a new write-only instance of ArbValue, bound to a specific deployed contract.

type ArbValueTransactorRaw 

type ArbValueTransactorRaw struct {
	Contract *ArbValueTransactor // Generic write-only contract binding to access the raw methods on
}

ArbValueTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ArbValueTransactorRaw) Transact 

func (_ArbValue *ArbValueTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ArbValueTransactorRaw) Transfer 

func (_ArbValue *ArbValueTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ArbValueTransactorSession 

type ArbValueTransactorSession struct {
	Contract     *ArbValueTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

ArbValueTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type BytesLib 

type BytesLib struct {
	BytesLibCaller     // Read-only binding to the contract
	BytesLibTransactor // Write-only binding to the contract
	BytesLibFilterer   // Log filterer for contract events
}

BytesLib is an auto generated Go binding around an Ethereum contract.

func DeployBytesLib 

func DeployBytesLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BytesLib, error)

DeployBytesLib deploys a new Ethereum contract, binding an instance of BytesLib to it.

func NewBytesLib 

func NewBytesLib(address common.Address, backend bind.ContractBackend) (*BytesLib, error)

NewBytesLib creates a new instance of BytesLib, bound to a specific deployed contract.

type BytesLibCaller 

type BytesLibCaller struct {
	// contains filtered or unexported fields
}

BytesLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewBytesLibCaller 

func NewBytesLibCaller(address common.Address, caller bind.ContractCaller) (*BytesLibCaller, error)

NewBytesLibCaller creates a new read-only instance of BytesLib, bound to a specific deployed contract.

type BytesLibCallerRaw 

type BytesLibCallerRaw struct {
	Contract *BytesLibCaller // Generic read-only contract binding to access the raw methods on
}

BytesLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*BytesLibCallerRaw) Call 

func (_BytesLib *BytesLibCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type BytesLibCallerSession 

type BytesLibCallerSession struct {
	Contract *BytesLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

BytesLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type BytesLibFilterer 

type BytesLibFilterer struct {
	// contains filtered or unexported fields
}

BytesLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewBytesLibFilterer 

func NewBytesLibFilterer(address common.Address, filterer bind.ContractFilterer) (*BytesLibFilterer, error)

NewBytesLibFilterer creates a new log filterer instance of BytesLib, bound to a specific deployed contract.

type BytesLibRaw 

type BytesLibRaw struct {
	Contract *BytesLib // Generic contract binding to access the raw methods on
}

BytesLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*BytesLibRaw) Call 

func (_BytesLib *BytesLibRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*BytesLibRaw) Transact 

func (_BytesLib *BytesLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*BytesLibRaw) Transfer 

func (_BytesLib *BytesLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type BytesLibSession 

type BytesLibSession struct {
	Contract     *BytesLib         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

BytesLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type BytesLibTransactor 

type BytesLibTransactor struct {
	// contains filtered or unexported fields
}

BytesLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewBytesLibTransactor 

func NewBytesLibTransactor(address common.Address, transactor bind.ContractTransactor) (*BytesLibTransactor, error)

NewBytesLibTransactor creates a new write-only instance of BytesLib, bound to a specific deployed contract.

type BytesLibTransactorRaw 

type BytesLibTransactorRaw struct {
	Contract *BytesLibTransactor // Generic write-only contract binding to access the raw methods on
}

BytesLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*BytesLibTransactorRaw) Transact 

func (_BytesLib *BytesLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*BytesLibTransactorRaw) Transfer 

func (_BytesLib *BytesLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type BytesLibTransactorSession 

type BytesLibTransactorSession struct {
	Contract     *BytesLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

BytesLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ChallengeManager 

type ChallengeManager struct {
	ChallengeManagerCaller     // Read-only binding to the contract
	ChallengeManagerTransactor // Write-only binding to the contract
	ChallengeManagerFilterer   // Log filterer for contract events
}

ChallengeManager is an auto generated Go binding around an Ethereum contract.

func DeployChallengeManager 

func DeployChallengeManager(auth *bind.TransactOpts, backend bind.ContractBackend, _vmTracker common.Address) (common.Address, *types.Transaction, *ChallengeManager, error)

DeployChallengeManager deploys a new Ethereum contract, binding an instance of ChallengeManager to it.

func NewChallengeManager 

func NewChallengeManager(address common.Address, backend bind.ContractBackend) (*ChallengeManager, error)

NewChallengeManager creates a new instance of ChallengeManager, bound to a specific deployed contract.

type ChallengeManagerBisectedAssertion 

type ChallengeManagerBisectedAssertion struct {
	VmId                                 [32]byte
	Bisecter                             common.Address
	AfterHashAndMessageAndLogsBisections [][32]byte
	TotalSteps                           uint32
	TotalMessageAmounts                  []*big.Int
	Raw                                  types.Log // Blockchain specific contextual infos
}

ChallengeManagerBisectedAssertion represents a BisectedAssertion event raised by the ChallengeManager contract.

type ChallengeManagerBisectedAssertionIterator 

type ChallengeManagerBisectedAssertionIterator struct {
	Event *ChallengeManagerBisectedAssertion // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ChallengeManagerBisectedAssertionIterator is returned from FilterBisectedAssertion and is used to iterate over the raw logs and unpacked data for BisectedAssertion events raised by the ChallengeManager contract.

func (*ChallengeManagerBisectedAssertionIterator) Close 

func (it *ChallengeManagerBisectedAssertionIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ChallengeManagerBisectedAssertionIterator) Error 

func (it *ChallengeManagerBisectedAssertionIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ChallengeManagerBisectedAssertionIterator) Next 

func (it *ChallengeManagerBisectedAssertionIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ChallengeManagerCaller 

type ChallengeManagerCaller struct {
	// contains filtered or unexported fields
}

ChallengeManagerCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewChallengeManagerCaller 

func NewChallengeManagerCaller(address common.Address, caller bind.ContractCaller) (*ChallengeManagerCaller, error)

NewChallengeManagerCaller creates a new read-only instance of ChallengeManager, bound to a specific deployed contract.

type ChallengeManagerCallerRaw 

type ChallengeManagerCallerRaw struct {
	Contract *ChallengeManagerCaller // Generic read-only contract binding to access the raw methods on
}

ChallengeManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ChallengeManagerCallerRaw) Call 

func (_ChallengeManager *ChallengeManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ChallengeManagerCallerSession 

type ChallengeManagerCallerSession struct {
	Contract *ChallengeManagerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts           // Call options to use throughout this session
}

ChallengeManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ChallengeManagerContinuedChallenge 

type ChallengeManagerContinuedChallenge struct {
	VmId           [32]byte
	Challenger     common.Address
	AssertionIndex *big.Int
	Raw            types.Log // Blockchain specific contextual infos
}

ChallengeManagerContinuedChallenge represents a ContinuedChallenge event raised by the ChallengeManager contract.

type ChallengeManagerContinuedChallengeIterator 

type ChallengeManagerContinuedChallengeIterator struct {
	Event *ChallengeManagerContinuedChallenge // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ChallengeManagerContinuedChallengeIterator is returned from FilterContinuedChallenge and is used to iterate over the raw logs and unpacked data for ContinuedChallenge events raised by the ChallengeManager contract.

func (*ChallengeManagerContinuedChallengeIterator) Close 

func (it *ChallengeManagerContinuedChallengeIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ChallengeManagerContinuedChallengeIterator) Error 

func (it *ChallengeManagerContinuedChallengeIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ChallengeManagerContinuedChallengeIterator) Next 

func (it *ChallengeManagerContinuedChallengeIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ChallengeManagerFilterer 

type ChallengeManagerFilterer struct {
	// contains filtered or unexported fields
}

ChallengeManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewChallengeManagerFilterer 

func NewChallengeManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*ChallengeManagerFilterer, error)

NewChallengeManagerFilterer creates a new log filterer instance of ChallengeManager, bound to a specific deployed contract.

func (*ChallengeManagerFilterer) FilterBisectedAssertion 

func (_ChallengeManager *ChallengeManagerFilterer) FilterBisectedAssertion(opts *bind.FilterOpts, vmId [][32]byte) (*ChallengeManagerBisectedAssertionIterator, error)

FilterBisectedAssertion is a free log retrieval operation binding the contract event 0xa4f8cbbd195d8e69d66b332eb24e05c24a35ee00de81da472b89ecb42a70ef71.

Solidity: event BisectedAssertion(bytes32 indexed vmId, address bisecter, bytes32[] afterHashAndMessageAndLogsBisections, uint32 totalSteps, uint256[] totalMessageAmounts)

func (*ChallengeManagerFilterer) FilterContinuedChallenge 

func (_ChallengeManager *ChallengeManagerFilterer) FilterContinuedChallenge(opts *bind.FilterOpts, vmId [][32]byte) (*ChallengeManagerContinuedChallengeIterator, error)

FilterContinuedChallenge is a free log retrieval operation binding the contract event 0xf5a6d1468c6ce7a03663fa2fd47dad9f6693a9289ebdbcf3309941caa75c7cf0.

Solidity: event ContinuedChallenge(bytes32 indexed vmId, address challenger, uint256 assertionIndex)

func (*ChallengeManagerFilterer) FilterOneStepProofCompleted 

func (_ChallengeManager *ChallengeManagerFilterer) FilterOneStepProofCompleted(opts *bind.FilterOpts, vmId [][32]byte) (*ChallengeManagerOneStepProofCompletedIterator, error)

FilterOneStepProofCompleted is a free log retrieval operation binding the contract event 0xb3b8389d4e8e450396d43f12a728c7a73784c6089340d0e904a24fd366ddaaff.

Solidity: event OneStepProofCompleted(bytes32 indexed vmId, address asserter, bytes proof)

func (*ChallengeManagerFilterer) FilterOneStepProofDebug 

func (_ChallengeManager *ChallengeManagerFilterer) FilterOneStepProofDebug(opts *bind.FilterOpts, vmId [][32]byte) (*ChallengeManagerOneStepProofDebugIterator, error)

FilterOneStepProofDebug is a free log retrieval operation binding the contract event 0x4c7f6075bf7890867239f4808f15728e984938b95252446d263cfdd1f5f6cb21.

Solidity: event OneStepProofDebug(bytes32 indexed vmId, bytes32[10] proofData)

func (*ChallengeManagerFilterer) FilterTimedOutChallenge 

func (_ChallengeManager *ChallengeManagerFilterer) FilterTimedOutChallenge(opts *bind.FilterOpts, vmId [][32]byte) (*ChallengeManagerTimedOutChallengeIterator, error)

FilterTimedOutChallenge is a free log retrieval operation binding the contract event 0x4bb5367552b51194ffa95563d907630acc956760789c62c6e92b82dfddf7e680.

Solidity: event TimedOutChallenge(bytes32 indexed vmId, bool challengerWrong)

func (*ChallengeManagerFilterer) WatchBisectedAssertion 

func (_ChallengeManager *ChallengeManagerFilterer) WatchBisectedAssertion(opts *bind.WatchOpts, sink chan<- *ChallengeManagerBisectedAssertion, vmId [][32]byte) (event.Subscription, error)

WatchBisectedAssertion is a free log subscription operation binding the contract event 0xa4f8cbbd195d8e69d66b332eb24e05c24a35ee00de81da472b89ecb42a70ef71.

Solidity: event BisectedAssertion(bytes32 indexed vmId, address bisecter, bytes32[] afterHashAndMessageAndLogsBisections, uint32 totalSteps, uint256[] totalMessageAmounts)

func (*ChallengeManagerFilterer) WatchContinuedChallenge 

func (_ChallengeManager *ChallengeManagerFilterer) WatchContinuedChallenge(opts *bind.WatchOpts, sink chan<- *ChallengeManagerContinuedChallenge, vmId [][32]byte) (event.Subscription, error)

WatchContinuedChallenge is a free log subscription operation binding the contract event 0xf5a6d1468c6ce7a03663fa2fd47dad9f6693a9289ebdbcf3309941caa75c7cf0.

Solidity: event ContinuedChallenge(bytes32 indexed vmId, address challenger, uint256 assertionIndex)

func (*ChallengeManagerFilterer) WatchOneStepProofCompleted 

func (_ChallengeManager *ChallengeManagerFilterer) WatchOneStepProofCompleted(opts *bind.WatchOpts, sink chan<- *ChallengeManagerOneStepProofCompleted, vmId [][32]byte) (event.Subscription, error)

WatchOneStepProofCompleted is a free log subscription operation binding the contract event 0xb3b8389d4e8e450396d43f12a728c7a73784c6089340d0e904a24fd366ddaaff.

Solidity: event OneStepProofCompleted(bytes32 indexed vmId, address asserter, bytes proof)

func (*ChallengeManagerFilterer) WatchOneStepProofDebug 

func (_ChallengeManager *ChallengeManagerFilterer) WatchOneStepProofDebug(opts *bind.WatchOpts, sink chan<- *ChallengeManagerOneStepProofDebug, vmId [][32]byte) (event.Subscription, error)

WatchOneStepProofDebug is a free log subscription operation binding the contract event 0x4c7f6075bf7890867239f4808f15728e984938b95252446d263cfdd1f5f6cb21.

Solidity: event OneStepProofDebug(bytes32 indexed vmId, bytes32[10] proofData)

func (*ChallengeManagerFilterer) WatchTimedOutChallenge 

func (_ChallengeManager *ChallengeManagerFilterer) WatchTimedOutChallenge(opts *bind.WatchOpts, sink chan<- *ChallengeManagerTimedOutChallenge, vmId [][32]byte) (event.Subscription, error)

WatchTimedOutChallenge is a free log subscription operation binding the contract event 0x4bb5367552b51194ffa95563d907630acc956760789c62c6e92b82dfddf7e680.

Solidity: event TimedOutChallenge(bytes32 indexed vmId, bool challengerWrong)

type ChallengeManagerOneStepProofCompleted 

type ChallengeManagerOneStepProofCompleted struct {
	VmId     [32]byte
	Asserter common.Address
	Proof    []byte
	Raw      types.Log // Blockchain specific contextual infos
}

ChallengeManagerOneStepProofCompleted represents a OneStepProofCompleted event raised by the ChallengeManager contract.

type ChallengeManagerOneStepProofCompletedIterator 

type ChallengeManagerOneStepProofCompletedIterator struct {
	Event *ChallengeManagerOneStepProofCompleted // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ChallengeManagerOneStepProofCompletedIterator is returned from FilterOneStepProofCompleted and is used to iterate over the raw logs and unpacked data for OneStepProofCompleted events raised by the ChallengeManager contract.

func (*ChallengeManagerOneStepProofCompletedIterator) Close 

func (it *ChallengeManagerOneStepProofCompletedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ChallengeManagerOneStepProofCompletedIterator) Error 

func (it *ChallengeManagerOneStepProofCompletedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ChallengeManagerOneStepProofCompletedIterator) Next 

func (it *ChallengeManagerOneStepProofCompletedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ChallengeManagerOneStepProofDebug 

type ChallengeManagerOneStepProofDebug struct {
	VmId      [32]byte
	ProofData [10][32]byte
	Raw       types.Log // Blockchain specific contextual infos
}

ChallengeManagerOneStepProofDebug represents a OneStepProofDebug event raised by the ChallengeManager contract.

type ChallengeManagerOneStepProofDebugIterator 

type ChallengeManagerOneStepProofDebugIterator struct {
	Event *ChallengeManagerOneStepProofDebug // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ChallengeManagerOneStepProofDebugIterator is returned from FilterOneStepProofDebug and is used to iterate over the raw logs and unpacked data for OneStepProofDebug events raised by the ChallengeManager contract.

func (*ChallengeManagerOneStepProofDebugIterator) Close 

func (it *ChallengeManagerOneStepProofDebugIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ChallengeManagerOneStepProofDebugIterator) Error 

func (it *ChallengeManagerOneStepProofDebugIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ChallengeManagerOneStepProofDebugIterator) Next 

func (it *ChallengeManagerOneStepProofDebugIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ChallengeManagerRaw 

type ChallengeManagerRaw struct {
	Contract *ChallengeManager // Generic contract binding to access the raw methods on
}

ChallengeManagerRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ChallengeManagerRaw) Call 

func (_ChallengeManager *ChallengeManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ChallengeManagerRaw) Transact 

func (_ChallengeManager *ChallengeManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ChallengeManagerRaw) Transfer 

func (_ChallengeManager *ChallengeManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ChallengeManagerSession 

type ChallengeManagerSession struct {
	Contract     *ChallengeManager // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ChallengeManagerSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ChallengeManagerSession) AsserterTimedOut 

func (_ChallengeManager *ChallengeManagerSession) AsserterTimedOut(_vmId [32]byte, _rootHash [32]byte, _deadline uint64) (*types.Transaction, error)

AsserterTimedOut is a paid mutator transaction binding the contract method 0x2923a1a7.

Solidity: function asserterTimedOut(bytes32 _vmId, bytes32 _rootHash, uint64 _deadline) returns()

func (*ChallengeManagerSession) BisectAssertion 

func (_ChallengeManager *ChallengeManagerSession) BisectAssertion(_fields [3][32]byte, _afterHashAndMessageAndLogsBisections [][32]byte, _totalMessageAmounts []*big.Int, _totalSteps uint32, _timeBounds [2]uint64, _tokenTypes [][21]byte, _beforeBalances []*big.Int, _deadline uint64) (*types.Transaction, error)

BisectAssertion is a paid mutator transaction binding the contract method 0x794614bd.

Solidity: function bisectAssertion(bytes32[3] _fields, bytes32[] _afterHashAndMessageAndLogsBisections, uint256[] _totalMessageAmounts, uint32 _totalSteps, uint64[2] _timeBounds, bytes21[] _tokenTypes, uint256[] _beforeBalances, uint64 _deadline) returns()

func (*ChallengeManagerSession) ChallengerTimedOut 

func (_ChallengeManager *ChallengeManagerSession) ChallengerTimedOut(_vmId [32]byte, _rootHash [32]byte, _deadline uint64) (*types.Transaction, error)

ChallengerTimedOut is a paid mutator transaction binding the contract method 0xf2b925ec.

Solidity: function challengerTimedOut(bytes32 _vmId, bytes32 _rootHash, uint64 _deadline) returns()

func (*ChallengeManagerSession) ContinueChallenge 

func (_ChallengeManager *ChallengeManagerSession) ContinueChallenge(_vmId [32]byte, _assertionToChallenge *big.Int, _proof []byte, _deadline uint64, _bisectionRoot [32]byte, _bisectionHash [32]byte) (*types.Transaction, error)

ContinueChallenge is a paid mutator transaction binding the contract method 0xbef810f5.

Solidity: function continueChallenge(bytes32 _vmId, uint256 _assertionToChallenge, bytes _proof, uint64 _deadline, bytes32 _bisectionRoot, bytes32 _bisectionHash) returns()

func (*ChallengeManagerSession) InitiateChallenge 

func (_ChallengeManager *ChallengeManagerSession) InitiateChallenge(_vmId [32]byte, _players [2]common.Address, _escrows [2]*big.Int, _challengePeriod uint32, _challengeRoot [32]byte) (*types.Transaction, error)

InitiateChallenge is a paid mutator transaction binding the contract method 0x2b50d42b.

Solidity: function initiateChallenge(bytes32 _vmId, address[2] _players, uint128[2] _escrows, uint32 _challengePeriod, bytes32 _challengeRoot) returns()

func (*ChallengeManagerSession) OneStepProof 

func (_ChallengeManager *ChallengeManagerSession) OneStepProof(_vmId [32]byte, _beforeHashAndInbox [2][32]byte, _timeBounds [2]uint64, _tokenTypes [][21]byte, _beforeBalances []*big.Int, _afterHashAndMessages [5][32]byte, _amounts []*big.Int, _proof []byte, _deadline uint64) (*types.Transaction, error)

OneStepProof is a paid mutator transaction binding the contract method 0xc1797777.

Solidity: function oneStepProof(bytes32 _vmId, bytes32[2] _beforeHashAndInbox, uint64[2] _timeBounds, bytes21[] _tokenTypes, uint256[] _beforeBalances, bytes32[5] _afterHashAndMessages, uint256[] _amounts, bytes _proof, uint64 _deadline) returns()

type ChallengeManagerTimedOutChallenge 

type ChallengeManagerTimedOutChallenge struct {
	VmId            [32]byte
	ChallengerWrong bool
	Raw             types.Log // Blockchain specific contextual infos
}

ChallengeManagerTimedOutChallenge represents a TimedOutChallenge event raised by the ChallengeManager contract.

type ChallengeManagerTimedOutChallengeIterator 

type ChallengeManagerTimedOutChallengeIterator struct {
	Event *ChallengeManagerTimedOutChallenge // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ChallengeManagerTimedOutChallengeIterator is returned from FilterTimedOutChallenge and is used to iterate over the raw logs and unpacked data for TimedOutChallenge events raised by the ChallengeManager contract.

func (*ChallengeManagerTimedOutChallengeIterator) Close 

func (it *ChallengeManagerTimedOutChallengeIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ChallengeManagerTimedOutChallengeIterator) Error 

func (it *ChallengeManagerTimedOutChallengeIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ChallengeManagerTimedOutChallengeIterator) Next 

func (it *ChallengeManagerTimedOutChallengeIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ChallengeManagerTransactor 

type ChallengeManagerTransactor struct {
	// contains filtered or unexported fields
}

ChallengeManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewChallengeManagerTransactor 

func NewChallengeManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*ChallengeManagerTransactor, error)

NewChallengeManagerTransactor creates a new write-only instance of ChallengeManager, bound to a specific deployed contract.

func (*ChallengeManagerTransactor) AsserterTimedOut 

func (_ChallengeManager *ChallengeManagerTransactor) AsserterTimedOut(opts *bind.TransactOpts, _vmId [32]byte, _rootHash [32]byte, _deadline uint64) (*types.Transaction, error)

AsserterTimedOut is a paid mutator transaction binding the contract method 0x2923a1a7.

Solidity: function asserterTimedOut(bytes32 _vmId, bytes32 _rootHash, uint64 _deadline) returns()

func (*ChallengeManagerTransactor) BisectAssertion 

func (_ChallengeManager *ChallengeManagerTransactor) BisectAssertion(opts *bind.TransactOpts, _fields [3][32]byte, _afterHashAndMessageAndLogsBisections [][32]byte, _totalMessageAmounts []*big.Int, _totalSteps uint32, _timeBounds [2]uint64, _tokenTypes [][21]byte, _beforeBalances []*big.Int, _deadline uint64) (*types.Transaction, error)

BisectAssertion is a paid mutator transaction binding the contract method 0x794614bd.

Solidity: function bisectAssertion(bytes32[3] _fields, bytes32[] _afterHashAndMessageAndLogsBisections, uint256[] _totalMessageAmounts, uint32 _totalSteps, uint64[2] _timeBounds, bytes21[] _tokenTypes, uint256[] _beforeBalances, uint64 _deadline) returns()

func (*ChallengeManagerTransactor) ChallengerTimedOut 

func (_ChallengeManager *ChallengeManagerTransactor) ChallengerTimedOut(opts *bind.TransactOpts, _vmId [32]byte, _rootHash [32]byte, _deadline uint64) (*types.Transaction, error)

ChallengerTimedOut is a paid mutator transaction binding the contract method 0xf2b925ec.

Solidity: function challengerTimedOut(bytes32 _vmId, bytes32 _rootHash, uint64 _deadline) returns()

func (*ChallengeManagerTransactor) ContinueChallenge 

func (_ChallengeManager *ChallengeManagerTransactor) ContinueChallenge(opts *bind.TransactOpts, _vmId [32]byte, _assertionToChallenge *big.Int, _proof []byte, _deadline uint64, _bisectionRoot [32]byte, _bisectionHash [32]byte) (*types.Transaction, error)

ContinueChallenge is a paid mutator transaction binding the contract method 0xbef810f5.

Solidity: function continueChallenge(bytes32 _vmId, uint256 _assertionToChallenge, bytes _proof, uint64 _deadline, bytes32 _bisectionRoot, bytes32 _bisectionHash) returns()

func (*ChallengeManagerTransactor) InitiateChallenge 

func (_ChallengeManager *ChallengeManagerTransactor) InitiateChallenge(opts *bind.TransactOpts, _vmId [32]byte, _players [2]common.Address, _escrows [2]*big.Int, _challengePeriod uint32, _challengeRoot [32]byte) (*types.Transaction, error)

InitiateChallenge is a paid mutator transaction binding the contract method 0x2b50d42b.

Solidity: function initiateChallenge(bytes32 _vmId, address[2] _players, uint128[2] _escrows, uint32 _challengePeriod, bytes32 _challengeRoot) returns()

func (*ChallengeManagerTransactor) OneStepProof 

func (_ChallengeManager *ChallengeManagerTransactor) OneStepProof(opts *bind.TransactOpts, _vmId [32]byte, _beforeHashAndInbox [2][32]byte, _timeBounds [2]uint64, _tokenTypes [][21]byte, _beforeBalances []*big.Int, _afterHashAndMessages [5][32]byte, _amounts []*big.Int, _proof []byte, _deadline uint64) (*types.Transaction, error)

OneStepProof is a paid mutator transaction binding the contract method 0xc1797777.

Solidity: function oneStepProof(bytes32 _vmId, bytes32[2] _beforeHashAndInbox, uint64[2] _timeBounds, bytes21[] _tokenTypes, uint256[] _beforeBalances, bytes32[5] _afterHashAndMessages, uint256[] _amounts, bytes _proof, uint64 _deadline) returns()

type ChallengeManagerTransactorRaw 

type ChallengeManagerTransactorRaw struct {
	Contract *ChallengeManagerTransactor // Generic write-only contract binding to access the raw methods on
}

ChallengeManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ChallengeManagerTransactorRaw) Transact 

func (_ChallengeManager *ChallengeManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ChallengeManagerTransactorRaw) Transfer 

func (_ChallengeManager *ChallengeManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ChallengeManagerTransactorSession 

type ChallengeManagerTransactorSession struct {
	Contract     *ChallengeManagerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts           // Transaction auth options to use throughout this session
}

ChallengeManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*ChallengeManagerTransactorSession) AsserterTimedOut 

func (_ChallengeManager *ChallengeManagerTransactorSession) AsserterTimedOut(_vmId [32]byte, _rootHash [32]byte, _deadline uint64) (*types.Transaction, error)

AsserterTimedOut is a paid mutator transaction binding the contract method 0x2923a1a7.

Solidity: function asserterTimedOut(bytes32 _vmId, bytes32 _rootHash, uint64 _deadline) returns()

func (*ChallengeManagerTransactorSession) BisectAssertion 

func (_ChallengeManager *ChallengeManagerTransactorSession) BisectAssertion(_fields [3][32]byte, _afterHashAndMessageAndLogsBisections [][32]byte, _totalMessageAmounts []*big.Int, _totalSteps uint32, _timeBounds [2]uint64, _tokenTypes [][21]byte, _beforeBalances []*big.Int, _deadline uint64) (*types.Transaction, error)

BisectAssertion is a paid mutator transaction binding the contract method 0x794614bd.

Solidity: function bisectAssertion(bytes32[3] _fields, bytes32[] _afterHashAndMessageAndLogsBisections, uint256[] _totalMessageAmounts, uint32 _totalSteps, uint64[2] _timeBounds, bytes21[] _tokenTypes, uint256[] _beforeBalances, uint64 _deadline) returns()

func (*ChallengeManagerTransactorSession) ChallengerTimedOut 

func (_ChallengeManager *ChallengeManagerTransactorSession) ChallengerTimedOut(_vmId [32]byte, _rootHash [32]byte, _deadline uint64) (*types.Transaction, error)

ChallengerTimedOut is a paid mutator transaction binding the contract method 0xf2b925ec.

Solidity: function challengerTimedOut(bytes32 _vmId, bytes32 _rootHash, uint64 _deadline) returns()

func (*ChallengeManagerTransactorSession) ContinueChallenge 

func (_ChallengeManager *ChallengeManagerTransactorSession) ContinueChallenge(_vmId [32]byte, _assertionToChallenge *big.Int, _proof []byte, _deadline uint64, _bisectionRoot [32]byte, _bisectionHash [32]byte) (*types.Transaction, error)

ContinueChallenge is a paid mutator transaction binding the contract method 0xbef810f5.

Solidity: function continueChallenge(bytes32 _vmId, uint256 _assertionToChallenge, bytes _proof, uint64 _deadline, bytes32 _bisectionRoot, bytes32 _bisectionHash) returns()

func (*ChallengeManagerTransactorSession) InitiateChallenge 

func (_ChallengeManager *ChallengeManagerTransactorSession) InitiateChallenge(_vmId [32]byte, _players [2]common.Address, _escrows [2]*big.Int, _challengePeriod uint32, _challengeRoot [32]byte) (*types.Transaction, error)

InitiateChallenge is a paid mutator transaction binding the contract method 0x2b50d42b.

Solidity: function initiateChallenge(bytes32 _vmId, address[2] _players, uint128[2] _escrows, uint32 _challengePeriod, bytes32 _challengeRoot) returns()

func (*ChallengeManagerTransactorSession) OneStepProof 

func (_ChallengeManager *ChallengeManagerTransactorSession) OneStepProof(_vmId [32]byte, _beforeHashAndInbox [2][32]byte, _timeBounds [2]uint64, _tokenTypes [][21]byte, _beforeBalances []*big.Int, _afterHashAndMessages [5][32]byte, _amounts []*big.Int, _proof []byte, _deadline uint64) (*types.Transaction, error)

OneStepProof is a paid mutator transaction binding the contract method 0xc1797777.

Solidity: function oneStepProof(bytes32 _vmId, bytes32[2] _beforeHashAndInbox, uint64[2] _timeBounds, bytes21[] _tokenTypes, uint256[] _beforeBalances, bytes32[5] _afterHashAndMessages, uint256[] _amounts, bytes _proof, uint64 _deadline) returns()

type IChallengeManager 

type IChallengeManager struct {
	IChallengeManagerCaller     // Read-only binding to the contract
	IChallengeManagerTransactor // Write-only binding to the contract
	IChallengeManagerFilterer   // Log filterer for contract events
}

IChallengeManager is an auto generated Go binding around an Ethereum contract.

func DeployIChallengeManager 

func DeployIChallengeManager(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IChallengeManager, error)

DeployIChallengeManager deploys a new Ethereum contract, binding an instance of IChallengeManager to it.

func NewIChallengeManager 

func NewIChallengeManager(address common.Address, backend bind.ContractBackend) (*IChallengeManager, error)

NewIChallengeManager creates a new instance of IChallengeManager, bound to a specific deployed contract.

type IChallengeManagerCaller 

type IChallengeManagerCaller struct {
	// contains filtered or unexported fields
}

IChallengeManagerCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewIChallengeManagerCaller 

func NewIChallengeManagerCaller(address common.Address, caller bind.ContractCaller) (*IChallengeManagerCaller, error)

NewIChallengeManagerCaller creates a new read-only instance of IChallengeManager, bound to a specific deployed contract.

type IChallengeManagerCallerRaw 

type IChallengeManagerCallerRaw struct {
	Contract *IChallengeManagerCaller // Generic read-only contract binding to access the raw methods on
}

IChallengeManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*IChallengeManagerCallerRaw) Call 

func (_IChallengeManager *IChallengeManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type IChallengeManagerCallerSession 

type IChallengeManagerCallerSession struct {
	Contract *IChallengeManagerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts            // Call options to use throughout this session
}

IChallengeManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type IChallengeManagerFilterer 

type IChallengeManagerFilterer struct {
	// contains filtered or unexported fields
}

IChallengeManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewIChallengeManagerFilterer 

func NewIChallengeManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*IChallengeManagerFilterer, error)

NewIChallengeManagerFilterer creates a new log filterer instance of IChallengeManager, bound to a specific deployed contract.

type IChallengeManagerRaw 

type IChallengeManagerRaw struct {
	Contract *IChallengeManager // Generic contract binding to access the raw methods on
}

IChallengeManagerRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*IChallengeManagerRaw) Call 

func (_IChallengeManager *IChallengeManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*IChallengeManagerRaw) Transact 

func (_IChallengeManager *IChallengeManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*IChallengeManagerRaw) Transfer 

func (_IChallengeManager *IChallengeManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type IChallengeManagerSession 

type IChallengeManagerSession struct {
	Contract     *IChallengeManager // Generic contract binding to set the session for
	CallOpts     bind.CallOpts      // Call options to use throughout this session
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

IChallengeManagerSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*IChallengeManagerSession) InitiateChallenge 

func (_IChallengeManager *IChallengeManagerSession) InitiateChallenge(vmId [32]byte, players [2]common.Address, escrows [2]*big.Int, challengePeriod uint32, challengeRoot [32]byte) (*types.Transaction, error)

InitiateChallenge is a paid mutator transaction binding the contract method 0x2b50d42b.

Solidity: function initiateChallenge(bytes32 vmId, address[2] players, uint128[2] escrows, uint32 challengePeriod, bytes32 challengeRoot) returns()

type IChallengeManagerTransactor 

type IChallengeManagerTransactor struct {
	// contains filtered or unexported fields
}

IChallengeManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewIChallengeManagerTransactor 

func NewIChallengeManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*IChallengeManagerTransactor, error)

NewIChallengeManagerTransactor creates a new write-only instance of IChallengeManager, bound to a specific deployed contract.

func (*IChallengeManagerTransactor) InitiateChallenge 

func (_IChallengeManager *IChallengeManagerTransactor) InitiateChallenge(opts *bind.TransactOpts, vmId [32]byte, players [2]common.Address, escrows [2]*big.Int, challengePeriod uint32, challengeRoot [32]byte) (*types.Transaction, error)

InitiateChallenge is a paid mutator transaction binding the contract method 0x2b50d42b.

Solidity: function initiateChallenge(bytes32 vmId, address[2] players, uint128[2] escrows, uint32 challengePeriod, bytes32 challengeRoot) returns()

type IChallengeManagerTransactorRaw 

type IChallengeManagerTransactorRaw struct {
	Contract *IChallengeManagerTransactor // Generic write-only contract binding to access the raw methods on
}

IChallengeManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*IChallengeManagerTransactorRaw) Transact 

func (_IChallengeManager *IChallengeManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*IChallengeManagerTransactorRaw) Transfer 

func (_IChallengeManager *IChallengeManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type IChallengeManagerTransactorSession 

type IChallengeManagerTransactorSession struct {
	Contract     *IChallengeManagerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts            // Transaction auth options to use throughout this session
}

IChallengeManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*IChallengeManagerTransactorSession) InitiateChallenge 

func (_IChallengeManager *IChallengeManagerTransactorSession) InitiateChallenge(vmId [32]byte, players [2]common.Address, escrows [2]*big.Int, challengePeriod uint32, challengeRoot [32]byte) (*types.Transaction, error)

InitiateChallenge is a paid mutator transaction binding the contract method 0x2b50d42b.

Solidity: function initiateChallenge(bytes32 vmId, address[2] players, uint128[2] escrows, uint32 challengePeriod, bytes32 challengeRoot) returns()

type IVMTracker 

type IVMTracker struct {
	IVMTrackerCaller     // Read-only binding to the contract
	IVMTrackerTransactor // Write-only binding to the contract
	IVMTrackerFilterer   // Log filterer for contract events
}

IVMTracker is an auto generated Go binding around an Ethereum contract.

func DeployIVMTracker 

func DeployIVMTracker(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IVMTracker, error)

DeployIVMTracker deploys a new Ethereum contract, binding an instance of IVMTracker to it.

func NewIVMTracker 

func NewIVMTracker(address common.Address, backend bind.ContractBackend) (*IVMTracker, error)

NewIVMTracker creates a new instance of IVMTracker, bound to a specific deployed contract.

type IVMTrackerCaller 

type IVMTrackerCaller struct {
	// contains filtered or unexported fields
}

IVMTrackerCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewIVMTrackerCaller 

func NewIVMTrackerCaller(address common.Address, caller bind.ContractCaller) (*IVMTrackerCaller, error)

NewIVMTrackerCaller creates a new read-only instance of IVMTracker, bound to a specific deployed contract.

type IVMTrackerCallerRaw 

type IVMTrackerCallerRaw struct {
	Contract *IVMTrackerCaller // Generic read-only contract binding to access the raw methods on
}

IVMTrackerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*IVMTrackerCallerRaw) Call 

func (_IVMTracker *IVMTrackerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type IVMTrackerCallerSession 

type IVMTrackerCallerSession struct {
	Contract *IVMTrackerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

IVMTrackerCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type IVMTrackerFilterer 

type IVMTrackerFilterer struct {
	// contains filtered or unexported fields
}

IVMTrackerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewIVMTrackerFilterer 

func NewIVMTrackerFilterer(address common.Address, filterer bind.ContractFilterer) (*IVMTrackerFilterer, error)

NewIVMTrackerFilterer creates a new log filterer instance of IVMTracker, bound to a specific deployed contract.

type IVMTrackerRaw 

type IVMTrackerRaw struct {
	Contract *IVMTracker // Generic contract binding to access the raw methods on
}

IVMTrackerRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*IVMTrackerRaw) Call 

func (_IVMTracker *IVMTrackerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*IVMTrackerRaw) Transact 

func (_IVMTracker *IVMTrackerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*IVMTrackerRaw) Transfer 

func (_IVMTracker *IVMTrackerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type IVMTrackerSession 

type IVMTrackerSession struct {
	Contract     *IVMTracker       // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

IVMTrackerSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*IVMTrackerSession) CompleteChallenge 

func (_IVMTracker *IVMTrackerSession) CompleteChallenge(_vmId [32]byte, _players [2]common.Address, _rewards [2]*big.Int) (*types.Transaction, error)

CompleteChallenge is a paid mutator transaction binding the contract method 0x63d84637.

Solidity: function completeChallenge(bytes32 _vmId, address[2] _players, uint128[2] _rewards) returns()

type IVMTrackerTransactor 

type IVMTrackerTransactor struct {
	// contains filtered or unexported fields
}

IVMTrackerTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewIVMTrackerTransactor 

func NewIVMTrackerTransactor(address common.Address, transactor bind.ContractTransactor) (*IVMTrackerTransactor, error)

NewIVMTrackerTransactor creates a new write-only instance of IVMTracker, bound to a specific deployed contract.

func (*IVMTrackerTransactor) CompleteChallenge 

func (_IVMTracker *IVMTrackerTransactor) CompleteChallenge(opts *bind.TransactOpts, _vmId [32]byte, _players [2]common.Address, _rewards [2]*big.Int) (*types.Transaction, error)

CompleteChallenge is a paid mutator transaction binding the contract method 0x63d84637.

Solidity: function completeChallenge(bytes32 _vmId, address[2] _players, uint128[2] _rewards) returns()

type IVMTrackerTransactorRaw 

type IVMTrackerTransactorRaw struct {
	Contract *IVMTrackerTransactor // Generic write-only contract binding to access the raw methods on
}

IVMTrackerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*IVMTrackerTransactorRaw) Transact 

func (_IVMTracker *IVMTrackerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*IVMTrackerTransactorRaw) Transfer 

func (_IVMTracker *IVMTrackerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type IVMTrackerTransactorSession 

type IVMTrackerTransactorSession struct {
	Contract     *IVMTrackerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

IVMTrackerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*IVMTrackerTransactorSession) CompleteChallenge 

func (_IVMTracker *IVMTrackerTransactorSession) CompleteChallenge(_vmId [32]byte, _players [2]common.Address, _rewards [2]*big.Int) (*types.Transaction, error)

CompleteChallenge is a paid mutator transaction binding the contract method 0x63d84637.

Solidity: function completeChallenge(bytes32 _vmId, address[2] _players, uint128[2] _rewards) returns()

type MerkleLib 

type MerkleLib struct {
	MerkleLibCaller     // Read-only binding to the contract
	MerkleLibTransactor // Write-only binding to the contract
	MerkleLibFilterer   // Log filterer for contract events
}

MerkleLib is an auto generated Go binding around an Ethereum contract.

func DeployMerkleLib 

func DeployMerkleLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MerkleLib, error)

DeployMerkleLib deploys a new Ethereum contract, binding an instance of MerkleLib to it.

func NewMerkleLib 

func NewMerkleLib(address common.Address, backend bind.ContractBackend) (*MerkleLib, error)

NewMerkleLib creates a new instance of MerkleLib, bound to a specific deployed contract.

type MerkleLibCaller 

type MerkleLibCaller struct {
	// contains filtered or unexported fields
}

MerkleLibCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewMerkleLibCaller 

func NewMerkleLibCaller(address common.Address, caller bind.ContractCaller) (*MerkleLibCaller, error)

NewMerkleLibCaller creates a new read-only instance of MerkleLib, bound to a specific deployed contract.

func (*MerkleLibCaller) GenerateAddressRoot 

func (_MerkleLib *MerkleLibCaller) GenerateAddressRoot(opts *bind.CallOpts, _addresses []common.Address) ([32]byte, error)

GenerateAddressRoot is a free data retrieval call binding the contract method 0x6a2dda67.

Solidity: function generateAddressRoot(address[] _addresses) constant returns(bytes32)

func (*MerkleLibCaller) GenerateRoot 

func (_MerkleLib *MerkleLibCaller) GenerateRoot(opts *bind.CallOpts, _hashes [][32]byte) ([32]byte, error)

GenerateRoot is a free data retrieval call binding the contract method 0x9898dc10.

Solidity: function generateRoot(bytes32[] _hashes) constant returns(bytes32)

func (*MerkleLibCaller) VerifyProof 

func (_MerkleLib *MerkleLibCaller) VerifyProof(opts *bind.CallOpts, proof []byte, root [32]byte, hash [32]byte, index *big.Int) (bool, error)

VerifyProof is a free data retrieval call binding the contract method 0xb792d767.

Solidity: function verifyProof(bytes proof, bytes32 root, bytes32 hash, uint256 index) constant returns(bool)

type MerkleLibCallerRaw 

type MerkleLibCallerRaw struct {
	Contract *MerkleLibCaller // Generic read-only contract binding to access the raw methods on
}

MerkleLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*MerkleLibCallerRaw) Call 

func (_MerkleLib *MerkleLibCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type MerkleLibCallerSession 

type MerkleLibCallerSession struct {
	Contract *MerkleLibCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts    // Call options to use throughout this session
}

MerkleLibCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*MerkleLibCallerSession) GenerateAddressRoot 

func (_MerkleLib *MerkleLibCallerSession) GenerateAddressRoot(_addresses []common.Address) ([32]byte, error)

GenerateAddressRoot is a free data retrieval call binding the contract method 0x6a2dda67.

Solidity: function generateAddressRoot(address[] _addresses) constant returns(bytes32)

func (*MerkleLibCallerSession) GenerateRoot 

func (_MerkleLib *MerkleLibCallerSession) GenerateRoot(_hashes [][32]byte) ([32]byte, error)

GenerateRoot is a free data retrieval call binding the contract method 0x9898dc10.

Solidity: function generateRoot(bytes32[] _hashes) constant returns(bytes32)

func (*MerkleLibCallerSession) VerifyProof 

func (_MerkleLib *MerkleLibCallerSession) VerifyProof(proof []byte, root [32]byte, hash [32]byte, index *big.Int) (bool, error)

VerifyProof is a free data retrieval call binding the contract method 0xb792d767.

Solidity: function verifyProof(bytes proof, bytes32 root, bytes32 hash, uint256 index) constant returns(bool)

type MerkleLibFilterer 

type MerkleLibFilterer struct {
	// contains filtered or unexported fields
}

MerkleLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewMerkleLibFilterer 

func NewMerkleLibFilterer(address common.Address, filterer bind.ContractFilterer) (*MerkleLibFilterer, error)

NewMerkleLibFilterer creates a new log filterer instance of MerkleLib, bound to a specific deployed contract.

type MerkleLibRaw 

type MerkleLibRaw struct {
	Contract *MerkleLib // Generic contract binding to access the raw methods on
}

MerkleLibRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*MerkleLibRaw) Call 

func (_MerkleLib *MerkleLibRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*MerkleLibRaw) Transact 

func (_MerkleLib *MerkleLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*MerkleLibRaw) Transfer 

func (_MerkleLib *MerkleLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MerkleLibSession 

type MerkleLibSession struct {
	Contract     *MerkleLib        // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

MerkleLibSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*MerkleLibSession) GenerateAddressRoot 

func (_MerkleLib *MerkleLibSession) GenerateAddressRoot(_addresses []common.Address) ([32]byte, error)

GenerateAddressRoot is a free data retrieval call binding the contract method 0x6a2dda67.

Solidity: function generateAddressRoot(address[] _addresses) constant returns(bytes32)

func (*MerkleLibSession) GenerateRoot 

func (_MerkleLib *MerkleLibSession) GenerateRoot(_hashes [][32]byte) ([32]byte, error)

GenerateRoot is a free data retrieval call binding the contract method 0x9898dc10.

Solidity: function generateRoot(bytes32[] _hashes) constant returns(bytes32)

func (*MerkleLibSession) VerifyProof 

func (_MerkleLib *MerkleLibSession) VerifyProof(proof []byte, root [32]byte, hash [32]byte, index *big.Int) (bool, error)

VerifyProof is a free data retrieval call binding the contract method 0xb792d767.

Solidity: function verifyProof(bytes proof, bytes32 root, bytes32 hash, uint256 index) constant returns(bool)

type MerkleLibTransactor 

type MerkleLibTransactor struct {
	// contains filtered or unexported fields
}

MerkleLibTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewMerkleLibTransactor 

func NewMerkleLibTransactor(address common.Address, transactor bind.ContractTransactor) (*MerkleLibTransactor, error)

NewMerkleLibTransactor creates a new write-only instance of MerkleLib, bound to a specific deployed contract.

type MerkleLibTransactorRaw 

type MerkleLibTransactorRaw struct {
	Contract *MerkleLibTransactor // Generic write-only contract binding to access the raw methods on
}

MerkleLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*MerkleLibTransactorRaw) Transact 

func (_MerkleLib *MerkleLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*MerkleLibTransactorRaw) Transfer 

func (_MerkleLib *MerkleLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MerkleLibTransactorSession 

type MerkleLibTransactorSession struct {
	Contract     *MerkleLibTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
}

MerkleLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type OneStepProof 

type OneStepProof struct {
	OneStepProofCaller     // Read-only binding to the contract
	OneStepProofTransactor // Write-only binding to the contract
	OneStepProofFilterer   // Log filterer for contract events
}

OneStepProof is an auto generated Go binding around an Ethereum contract.

func DeployOneStepProof 

func DeployOneStepProof(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *OneStepProof, error)

DeployOneStepProof deploys a new Ethereum contract, binding an instance of OneStepProof to it.

func NewOneStepProof 

func NewOneStepProof(address common.Address, backend bind.ContractBackend) (*OneStepProof, error)

NewOneStepProof creates a new instance of OneStepProof, bound to a specific deployed contract.

type OneStepProofCaller 

type OneStepProofCaller struct {
	// contains filtered or unexported fields
}

OneStepProofCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewOneStepProofCaller 

func NewOneStepProofCaller(address common.Address, caller bind.ContractCaller) (*OneStepProofCaller, error)

NewOneStepProofCaller creates a new read-only instance of OneStepProof, bound to a specific deployed contract.

func (*OneStepProofCaller) ValidateProof 

func (_OneStepProof *OneStepProofCaller) ValidateProof(opts *bind.CallOpts, fields [7][32]byte, timeBounds [2]uint64, tokenTypes [][21]byte, beforeValues []*big.Int, messageValue []*big.Int, proof []byte) (*big.Int, error)

ValidateProof is a free data retrieval call binding the contract method 0x0eca9f13.

Solidity: function validateProof(bytes32[7] fields, uint64[2] timeBounds, bytes21[] tokenTypes, uint256[] beforeValues, uint256[] messageValue, bytes proof) constant returns(uint256)

type OneStepProofCallerRaw 

type OneStepProofCallerRaw struct {
	Contract *OneStepProofCaller // Generic read-only contract binding to access the raw methods on
}

OneStepProofCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*OneStepProofCallerRaw) Call 

func (_OneStepProof *OneStepProofCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type OneStepProofCallerSession 

type OneStepProofCallerSession struct {
	Contract *OneStepProofCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts       // Call options to use throughout this session
}

OneStepProofCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*OneStepProofCallerSession) ValidateProof 

func (_OneStepProof *OneStepProofCallerSession) ValidateProof(fields [7][32]byte, timeBounds [2]uint64, tokenTypes [][21]byte, beforeValues []*big.Int, messageValue []*big.Int, proof []byte) (*big.Int, error)

ValidateProof is a free data retrieval call binding the contract method 0x0eca9f13.

Solidity: function validateProof(bytes32[7] fields, uint64[2] timeBounds, bytes21[] tokenTypes, uint256[] beforeValues, uint256[] messageValue, bytes proof) constant returns(uint256)

type OneStepProofFilterer 

type OneStepProofFilterer struct {
	// contains filtered or unexported fields
}

OneStepProofFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewOneStepProofFilterer 

func NewOneStepProofFilterer(address common.Address, filterer bind.ContractFilterer) (*OneStepProofFilterer, error)

NewOneStepProofFilterer creates a new log filterer instance of OneStepProof, bound to a specific deployed contract.

func (*OneStepProofFilterer) FilterSawMachine 

func (_OneStepProof *OneStepProofFilterer) FilterSawMachine(opts *bind.FilterOpts) (*OneStepProofSawMachineIterator, error)

FilterSawMachine is a free log retrieval operation binding the contract event 0x10d11f456a57c1ced446abc92b6cfa3854cd21f069b29f283252b23223d03080.

Solidity: event SawMachine(bytes32 instructionStack, bytes32 dataStack, bytes32 auxStack, bytes32 register, bytes32 staticHash, bytes32 errHandler)

func (*OneStepProofFilterer) WatchSawMachine 

func (_OneStepProof *OneStepProofFilterer) WatchSawMachine(opts *bind.WatchOpts, sink chan<- *OneStepProofSawMachine) (event.Subscription, error)

WatchSawMachine is a free log subscription operation binding the contract event 0x10d11f456a57c1ced446abc92b6cfa3854cd21f069b29f283252b23223d03080.

Solidity: event SawMachine(bytes32 instructionStack, bytes32 dataStack, bytes32 auxStack, bytes32 register, bytes32 staticHash, bytes32 errHandler)

type OneStepProofRaw 

type OneStepProofRaw struct {
	Contract *OneStepProof // Generic contract binding to access the raw methods on
}

OneStepProofRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*OneStepProofRaw) Call 

func (_OneStepProof *OneStepProofRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*OneStepProofRaw) Transact 

func (_OneStepProof *OneStepProofRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OneStepProofRaw) Transfer 

func (_OneStepProof *OneStepProofRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OneStepProofSawMachine 

type OneStepProofSawMachine struct {
	InstructionStack [32]byte
	DataStack        [32]byte
	AuxStack         [32]byte
	Register         [32]byte
	StaticHash       [32]byte
	ErrHandler       [32]byte
	Raw              types.Log // Blockchain specific contextual infos
}

OneStepProofSawMachine represents a SawMachine event raised by the OneStepProof contract.

type OneStepProofSawMachineIterator 

type OneStepProofSawMachineIterator struct {
	Event *OneStepProofSawMachine // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

OneStepProofSawMachineIterator is returned from FilterSawMachine and is used to iterate over the raw logs and unpacked data for SawMachine events raised by the OneStepProof contract.

func (*OneStepProofSawMachineIterator) Close 

func (it *OneStepProofSawMachineIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*OneStepProofSawMachineIterator) Error 

func (it *OneStepProofSawMachineIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OneStepProofSawMachineIterator) Next 

func (it *OneStepProofSawMachineIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type OneStepProofSession 

type OneStepProofSession struct {
	Contract     *OneStepProof     // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

OneStepProofSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*OneStepProofSession) ValidateProof 

func (_OneStepProof *OneStepProofSession) ValidateProof(fields [7][32]byte, timeBounds [2]uint64, tokenTypes [][21]byte, beforeValues []*big.Int, messageValue []*big.Int, proof []byte) (*big.Int, error)

ValidateProof is a free data retrieval call binding the contract method 0x0eca9f13.

Solidity: function validateProof(bytes32[7] fields, uint64[2] timeBounds, bytes21[] tokenTypes, uint256[] beforeValues, uint256[] messageValue, bytes proof) constant returns(uint256)

type OneStepProofTransactor 

type OneStepProofTransactor struct {
	// contains filtered or unexported fields
}

OneStepProofTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewOneStepProofTransactor 

func NewOneStepProofTransactor(address common.Address, transactor bind.ContractTransactor) (*OneStepProofTransactor, error)

NewOneStepProofTransactor creates a new write-only instance of OneStepProof, bound to a specific deployed contract.

type OneStepProofTransactorRaw 

type OneStepProofTransactorRaw struct {
	Contract *OneStepProofTransactor // Generic write-only contract binding to access the raw methods on
}

OneStepProofTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*OneStepProofTransactorRaw) Transact 

func (_OneStepProof *OneStepProofTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OneStepProofTransactorRaw) Transfer 

func (_OneStepProof *OneStepProofTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OneStepProofTransactorSession 

type OneStepProofTransactorSession struct {
	Contract     *OneStepProofTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

OneStepProofTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.