contracts

package

Go to main page

Versions in this module

v0

v0.0.3

Apr 16, 2025

v0.0.2

Apr 15, 2025

Changes in this version

+ var DataAvailabilityABI = DataAvailabilityMetaData.ABI

+ var DataAvailabilityMetaData = &bind.MetaData

type ApplicationCaller

+ func (_Application *ApplicationCaller) GetDataAvailability(opts *bind.CallOpts) ([]byte, error)

+ func (_Application *ApplicationCaller) GetDeploymentBlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_Application *ApplicationCaller) GetOutputsMerkleRootValidator(opts *bind.CallOpts) (common.Address, error)

type ApplicationCallerSession

+ func (_Application *ApplicationCallerSession) GetDataAvailability() ([]byte, error)

+ func (_Application *ApplicationCallerSession) GetDeploymentBlockNumber() (*big.Int, error)

+ func (_Application *ApplicationCallerSession) GetOutputsMerkleRootValidator() (common.Address, error)

type ApplicationFilterer

+ func (_Application *ApplicationFilterer) FilterOutputsMerkleRootValidatorChanged(opts *bind.FilterOpts) (*ApplicationOutputsMerkleRootValidatorChangedIterator, error)

+ func (_Application *ApplicationFilterer) ParseOutputsMerkleRootValidatorChanged(log types.Log) (*ApplicationOutputsMerkleRootValidatorChanged, error)

+ func (_Application *ApplicationFilterer) WatchOutputsMerkleRootValidatorChanged(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type ApplicationOutputsMerkleRootValidatorChanged struct

+ NewOutputsMerkleRootValidator common.Address

+ Raw types.Log

+ type ApplicationOutputsMerkleRootValidatorChangedIterator struct

+ Event *ApplicationOutputsMerkleRootValidatorChanged

+ func (it *ApplicationOutputsMerkleRootValidatorChangedIterator) Close() error

+ func (it *ApplicationOutputsMerkleRootValidatorChangedIterator) Error() error

+ func (it *ApplicationOutputsMerkleRootValidatorChangedIterator) Next() bool

type ApplicationSession

+ func (_Application *ApplicationSession) GetDataAvailability() ([]byte, error)

+ func (_Application *ApplicationSession) GetDeploymentBlockNumber() (*big.Int, error)

+ func (_Application *ApplicationSession) GetOutputsMerkleRootValidator() (common.Address, error)

+ func (_Application *ApplicationSession) MigrateToOutputsMerkleRootValidator(newOutputsMerkleRootValidator common.Address) (*types.Transaction, error)

type ApplicationTransactor

+ func (_Application *ApplicationTransactor) MigrateToOutputsMerkleRootValidator(opts *bind.TransactOpts, newOutputsMerkleRootValidator common.Address) (*types.Transaction, error)

type ApplicationTransactorSession

+ func (_Application *ApplicationTransactorSession) MigrateToOutputsMerkleRootValidator(newOutputsMerkleRootValidator common.Address) (*types.Transaction, error)

+ type DataAvailability struct

+ func NewDataAvailability(address common.Address, backend bind.ContractBackend) (*DataAvailability, error)

+ type DataAvailabilityCaller struct

+ func NewDataAvailabilityCaller(address common.Address, caller bind.ContractCaller) (*DataAvailabilityCaller, error)

+ type DataAvailabilityCallerRaw struct

+ Contract *DataAvailabilityCaller

+ func (_DataAvailability *DataAvailabilityCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type DataAvailabilityCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DataAvailabilityCaller

+ type DataAvailabilityFilterer struct

+ func NewDataAvailabilityFilterer(address common.Address, filterer bind.ContractFilterer) (*DataAvailabilityFilterer, error)

+ type DataAvailabilityRaw struct

+ Contract *DataAvailability

+ func (_DataAvailability *DataAvailabilityRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_DataAvailability *DataAvailabilityRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_DataAvailability *DataAvailabilityRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DataAvailabilitySession struct

+ CallOpts bind.CallOpts

+ Contract *DataAvailability

+ TransactOpts bind.TransactOpts

+ func (_DataAvailability *DataAvailabilitySession) InputBox(inputBox common.Address) (*types.Transaction, error)

+ func (_DataAvailability *DataAvailabilitySession) InputBoxAndEspresso(inputBox common.Address, fromBlock *big.Int, namespaceId uint32) (*types.Transaction, error)

+ type DataAvailabilityTransactor struct

+ func NewDataAvailabilityTransactor(address common.Address, transactor bind.ContractTransactor) (*DataAvailabilityTransactor, error)

+ func (_DataAvailability *DataAvailabilityTransactor) InputBox(opts *bind.TransactOpts, inputBox common.Address) (*types.Transaction, error)

+ func (_DataAvailability *DataAvailabilityTransactor) InputBoxAndEspresso(opts *bind.TransactOpts, inputBox common.Address, fromBlock *big.Int, ...) (*types.Transaction, error)

+ type DataAvailabilityTransactorRaw struct

+ Contract *DataAvailabilityTransactor

+ func (_DataAvailability *DataAvailabilityTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_DataAvailability *DataAvailabilityTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DataAvailabilityTransactorSession struct

+ Contract *DataAvailabilityTransactor

+ TransactOpts bind.TransactOpts

+ func (_DataAvailability *DataAvailabilityTransactorSession) InputBox(inputBox common.Address) (*types.Transaction, error)

+ func (_DataAvailability *DataAvailabilityTransactorSession) InputBoxAndEspresso(inputBox common.Address, fromBlock *big.Int, namespaceId uint32) (*types.Transaction, error)

type IApplicationFactoryApplicationCreated

+ DataAvailability []byte

+ OutputsMerkleRootValidator common.Address

type IConsensusCaller

+ func (_IConsensus *IConsensusCaller) IsOutputsMerkleRootValid(opts *bind.CallOpts, appContract common.Address, outputsMerkleRoot [32]byte) (bool, error)

+ func (_IConsensus *IConsensusCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

type IConsensusCallerSession

+ func (_IConsensus *IConsensusCallerSession) IsOutputsMerkleRootValid(appContract common.Address, outputsMerkleRoot [32]byte) (bool, error)

+ func (_IConsensus *IConsensusCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type IConsensusClaimAccepted struct

+ AppContract common.Address

+ LastProcessedBlockNumber *big.Int

+ OutputsMerkleRoot [32]byte

+ Raw types.Log

+ type IConsensusClaimAcceptedIterator struct

+ Event *IConsensusClaimAccepted

+ func (it *IConsensusClaimAcceptedIterator) Close() error

+ func (it *IConsensusClaimAcceptedIterator) Error() error

+ func (it *IConsensusClaimAcceptedIterator) Next() bool

+ type IConsensusClaimSubmitted struct

+ AppContract common.Address

+ LastProcessedBlockNumber *big.Int

+ OutputsMerkleRoot [32]byte

+ Raw types.Log

+ Submitter common.Address

+ type IConsensusClaimSubmittedIterator struct

+ Event *IConsensusClaimSubmitted

+ func (it *IConsensusClaimSubmittedIterator) Close() error

+ func (it *IConsensusClaimSubmittedIterator) Error() error

+ func (it *IConsensusClaimSubmittedIterator) Next() bool

type IConsensusFilterer

+ func (_IConsensus *IConsensusFilterer) FilterClaimAccepted(opts *bind.FilterOpts, appContract []common.Address) (*IConsensusClaimAcceptedIterator, error)

+ func (_IConsensus *IConsensusFilterer) FilterClaimSubmitted(opts *bind.FilterOpts, submitter []common.Address, ...) (*IConsensusClaimSubmittedIterator, error)

+ func (_IConsensus *IConsensusFilterer) ParseClaimAccepted(log types.Log) (*IConsensusClaimAccepted, error)

+ func (_IConsensus *IConsensusFilterer) ParseClaimSubmitted(log types.Log) (*IConsensusClaimSubmitted, error)

+ func (_IConsensus *IConsensusFilterer) WatchClaimAccepted(opts *bind.WatchOpts, sink chan<- *IConsensusClaimAccepted, ...) (event.Subscription, error)

+ func (_IConsensus *IConsensusFilterer) WatchClaimSubmitted(opts *bind.WatchOpts, sink chan<- *IConsensusClaimSubmitted, ...) (event.Subscription, error)

type IConsensusSession

+ func (_IConsensus *IConsensusSession) IsOutputsMerkleRootValid(appContract common.Address, outputsMerkleRoot [32]byte) (bool, error)

+ func (_IConsensus *IConsensusSession) SupportsInterface(interfaceId [4]byte) (bool, error)

type InputBoxCaller

+ func (_InputBox *InputBoxCaller) GetDeploymentBlockNumber(opts *bind.CallOpts) (*big.Int, error)

type InputBoxCallerSession

+ func (_InputBox *InputBoxCallerSession) GetDeploymentBlockNumber() (*big.Int, error)

type InputBoxSession

+ func (_InputBox *InputBoxSession) GetDeploymentBlockNumber() (*big.Int, error)

v0.0.1

Apr 8, 2025

v0.0.0

Apr 8, 2025

Changes in this version

+ var ApplicationABI = ApplicationMetaData.ABI

+ var ApplicationMetaData = &bind.MetaData

+ var EIP712ABI = EIP712MetaData.ABI

+ var EIP712MetaData = &bind.MetaData

+ var IApplicationFactoryABI = IApplicationFactoryMetaData.ABI

+ var IApplicationFactoryMetaData = &bind.MetaData

+ var IAuthorityFactoryABI = IAuthorityFactoryMetaData.ABI

+ var IAuthorityFactoryMetaData = &bind.MetaData

+ var IConsensusABI = IConsensusMetaData.ABI

+ var IConsensusMetaData = &bind.MetaData

+ var InputBoxABI = InputBoxMetaData.ABI

+ var InputBoxMetaData = &bind.MetaData

+ var InputsABI = InputsMetaData.ABI

+ var InputsMetaData = &bind.MetaData

+ var OutputsABI = OutputsMetaData.ABI

+ var OutputsMetaData = &bind.MetaData

+ type Application struct

+ func NewApplication(address common.Address, backend bind.ContractBackend) (*Application, error)

+ type ApplicationCaller struct

+ func NewApplicationCaller(address common.Address, caller bind.ContractCaller) (*ApplicationCaller, error)

+ func (_Application *ApplicationCaller) GetConsensus(opts *bind.CallOpts) (common.Address, error)

+ func (_Application *ApplicationCaller) GetTemplateHash(opts *bind.CallOpts) ([32]byte, error)

+ func (_Application *ApplicationCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Application *ApplicationCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_Application *ApplicationCaller) ValidateOutput(opts *bind.CallOpts, output []byte, proof OutputValidityProof) error

+ func (_Application *ApplicationCaller) ValidateOutputHash(opts *bind.CallOpts, outputHash [32]byte, proof OutputValidityProof) error

+ func (_Application *ApplicationCaller) WasOutputExecuted(opts *bind.CallOpts, outputIndex *big.Int) (bool, error)

+ type ApplicationCallerRaw struct

+ Contract *ApplicationCaller

+ func (_Application *ApplicationCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ApplicationCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ApplicationCaller

+ func (_Application *ApplicationCallerSession) GetConsensus() (common.Address, error)

+ func (_Application *ApplicationCallerSession) GetTemplateHash() ([32]byte, error)

+ func (_Application *ApplicationCallerSession) Owner() (common.Address, error)

+ func (_Application *ApplicationCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_Application *ApplicationCallerSession) ValidateOutput(output []byte, proof OutputValidityProof) error

+ func (_Application *ApplicationCallerSession) ValidateOutputHash(outputHash [32]byte, proof OutputValidityProof) error

+ func (_Application *ApplicationCallerSession) WasOutputExecuted(outputIndex *big.Int) (bool, error)

+ type ApplicationFilterer struct

+ func NewApplicationFilterer(address common.Address, filterer bind.ContractFilterer) (*ApplicationFilterer, error)

+ func (_Application *ApplicationFilterer) FilterNewConsensus(opts *bind.FilterOpts) (*ApplicationNewConsensusIterator, error)

+ func (_Application *ApplicationFilterer) FilterOutputExecuted(opts *bind.FilterOpts) (*ApplicationOutputExecutedIterator, error)

+ func (_Application *ApplicationFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*ApplicationOwnershipTransferredIterator, error)

+ func (_Application *ApplicationFilterer) ParseNewConsensus(log types.Log) (*ApplicationNewConsensus, error)

+ func (_Application *ApplicationFilterer) ParseOutputExecuted(log types.Log) (*ApplicationOutputExecuted, error)

+ func (_Application *ApplicationFilterer) ParseOwnershipTransferred(log types.Log) (*ApplicationOwnershipTransferred, error)

+ func (_Application *ApplicationFilterer) WatchNewConsensus(opts *bind.WatchOpts, sink chan<- *ApplicationNewConsensus) (event.Subscription, error)

+ func (_Application *ApplicationFilterer) WatchOutputExecuted(opts *bind.WatchOpts, sink chan<- *ApplicationOutputExecuted) (event.Subscription, error)

+ func (_Application *ApplicationFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ApplicationOwnershipTransferred, ...) (event.Subscription, error)

+ type ApplicationNewConsensus struct

+ NewConsensus common.Address

+ Raw types.Log

+ type ApplicationNewConsensusIterator struct

+ Event *ApplicationNewConsensus

+ func (it *ApplicationNewConsensusIterator) Close() error

+ func (it *ApplicationNewConsensusIterator) Error() error

+ func (it *ApplicationNewConsensusIterator) Next() bool

+ type ApplicationOutputExecuted struct

+ Output []byte

+ OutputIndex uint64

+ Raw types.Log

+ type ApplicationOutputExecutedIterator struct

+ Event *ApplicationOutputExecuted

+ func (it *ApplicationOutputExecutedIterator) Close() error

+ func (it *ApplicationOutputExecutedIterator) Error() error

+ func (it *ApplicationOutputExecutedIterator) Next() bool

+ type ApplicationOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type ApplicationOwnershipTransferredIterator struct

+ Event *ApplicationOwnershipTransferred

+ func (it *ApplicationOwnershipTransferredIterator) Close() error

+ func (it *ApplicationOwnershipTransferredIterator) Error() error

+ func (it *ApplicationOwnershipTransferredIterator) Next() bool

+ type ApplicationRaw struct

+ Contract *Application

+ func (_Application *ApplicationRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Application *ApplicationRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Application *ApplicationRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ApplicationSession struct

+ CallOpts bind.CallOpts

+ Contract *Application

+ TransactOpts bind.TransactOpts

+ func (_Application *ApplicationSession) ExecuteOutput(output []byte, proof OutputValidityProof) (*types.Transaction, error)

+ func (_Application *ApplicationSession) GetConsensus() (common.Address, error)

+ func (_Application *ApplicationSession) GetTemplateHash() ([32]byte, error)

+ func (_Application *ApplicationSession) MigrateToConsensus(newConsensus common.Address) (*types.Transaction, error)

+ func (_Application *ApplicationSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, ...) (*types.Transaction, error)

+ func (_Application *ApplicationSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, ...) (*types.Transaction, error)

+ func (_Application *ApplicationSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error)

+ func (_Application *ApplicationSession) Owner() (common.Address, error)

+ func (_Application *ApplicationSession) Receive() (*types.Transaction, error)

+ func (_Application *ApplicationSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Application *ApplicationSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_Application *ApplicationSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Application *ApplicationSession) ValidateOutput(output []byte, proof OutputValidityProof) error

+ func (_Application *ApplicationSession) ValidateOutputHash(outputHash [32]byte, proof OutputValidityProof) error

+ func (_Application *ApplicationSession) WasOutputExecuted(outputIndex *big.Int) (bool, error)

+ type ApplicationTransactor struct

+ func NewApplicationTransactor(address common.Address, transactor bind.ContractTransactor) (*ApplicationTransactor, error)

+ func (_Application *ApplicationTransactor) ExecuteOutput(opts *bind.TransactOpts, output []byte, proof OutputValidityProof) (*types.Transaction, error)

+ func (_Application *ApplicationTransactor) MigrateToConsensus(opts *bind.TransactOpts, newConsensus common.Address) (*types.Transaction, error)

+ func (_Application *ApplicationTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_Application *ApplicationTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_Application *ApplicationTransactor) OnERC721Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_Application *ApplicationTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Application *ApplicationTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Application *ApplicationTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type ApplicationTransactorRaw struct

+ Contract *ApplicationTransactor

+ func (_Application *ApplicationTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Application *ApplicationTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ApplicationTransactorSession struct

+ Contract *ApplicationTransactor

+ TransactOpts bind.TransactOpts

+ func (_Application *ApplicationTransactorSession) ExecuteOutput(output []byte, proof OutputValidityProof) (*types.Transaction, error)

+ func (_Application *ApplicationTransactorSession) MigrateToConsensus(newConsensus common.Address) (*types.Transaction, error)

+ func (_Application *ApplicationTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, ...) (*types.Transaction, error)

+ func (_Application *ApplicationTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, ...) (*types.Transaction, error)

+ func (_Application *ApplicationTransactorSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error)

+ func (_Application *ApplicationTransactorSession) Receive() (*types.Transaction, error)

+ func (_Application *ApplicationTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Application *ApplicationTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type EIP712 struct

+ func NewEIP712(address common.Address, backend bind.ContractBackend) (*EIP712, error)

+ type EIP712Caller struct

+ func NewEIP712Caller(address common.Address, caller bind.ContractCaller) (*EIP712Caller, error)

+ func (_EIP712 *EIP712Caller) Eip712Domain(opts *bind.CallOpts) (struct{ ... }, error)

+ type EIP712CallerRaw struct

+ Contract *EIP712Caller

+ func (_EIP712 *EIP712CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type EIP712CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *EIP712Caller

+ func (_EIP712 *EIP712CallerSession) Eip712Domain() (struct{ ... }, error)

+ type EIP712EIP712DomainChanged struct

+ Raw types.Log

+ type EIP712EIP712DomainChangedIterator struct

+ Event *EIP712EIP712DomainChanged

+ func (it *EIP712EIP712DomainChangedIterator) Close() error

+ func (it *EIP712EIP712DomainChangedIterator) Error() error

+ func (it *EIP712EIP712DomainChangedIterator) Next() bool

+ type EIP712Filterer struct

+ func NewEIP712Filterer(address common.Address, filterer bind.ContractFilterer) (*EIP712Filterer, error)

+ func (_EIP712 *EIP712Filterer) FilterEIP712DomainChanged(opts *bind.FilterOpts) (*EIP712EIP712DomainChangedIterator, error)

+ func (_EIP712 *EIP712Filterer) ParseEIP712DomainChanged(log types.Log) (*EIP712EIP712DomainChanged, error)

+ func (_EIP712 *EIP712Filterer) WatchEIP712DomainChanged(opts *bind.WatchOpts, sink chan<- *EIP712EIP712DomainChanged) (event.Subscription, error)

+ type EIP712Raw struct

+ Contract *EIP712

+ func (_EIP712 *EIP712Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_EIP712 *EIP712Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_EIP712 *EIP712Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EIP712Session struct

+ CallOpts bind.CallOpts

+ Contract *EIP712

+ TransactOpts bind.TransactOpts

+ func (_EIP712 *EIP712Session) Eip712Domain() (struct{ ... }, error)

+ type EIP712Transactor struct

+ func NewEIP712Transactor(address common.Address, transactor bind.ContractTransactor) (*EIP712Transactor, error)

+ type EIP712TransactorRaw struct

+ Contract *EIP712Transactor

+ func (_EIP712 *EIP712TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_EIP712 *EIP712TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EIP712TransactorSession struct

+ Contract *EIP712Transactor

+ TransactOpts bind.TransactOpts

+ type IApplicationFactory struct

+ func NewIApplicationFactory(address common.Address, backend bind.ContractBackend) (*IApplicationFactory, error)

+ type IApplicationFactoryApplicationCreated struct

+ AppContract common.Address

+ AppOwner common.Address

+ Consensus common.Address

+ Raw types.Log

+ TemplateHash [32]byte

+ type IApplicationFactoryApplicationCreatedIterator struct

+ Event *IApplicationFactoryApplicationCreated

+ func (it *IApplicationFactoryApplicationCreatedIterator) Close() error

+ func (it *IApplicationFactoryApplicationCreatedIterator) Error() error

+ func (it *IApplicationFactoryApplicationCreatedIterator) Next() bool

+ type IApplicationFactoryCaller struct

+ func NewIApplicationFactoryCaller(address common.Address, caller bind.ContractCaller) (*IApplicationFactoryCaller, error)

+ func (_IApplicationFactory *IApplicationFactoryCaller) CalculateApplicationAddress(opts *bind.CallOpts, consensus common.Address, appOwner common.Address, ...) (common.Address, error)

+ type IApplicationFactoryCallerRaw struct

+ Contract *IApplicationFactoryCaller

+ func (_IApplicationFactory *IApplicationFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type IApplicationFactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IApplicationFactoryCaller

+ func (_IApplicationFactory *IApplicationFactoryCallerSession) CalculateApplicationAddress(consensus common.Address, appOwner common.Address, templateHash [32]byte, ...) (common.Address, error)

+ type IApplicationFactoryFilterer struct

+ func NewIApplicationFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*IApplicationFactoryFilterer, error)

+ func (_IApplicationFactory *IApplicationFactoryFilterer) FilterApplicationCreated(opts *bind.FilterOpts, consensus []common.Address) (*IApplicationFactoryApplicationCreatedIterator, error)

+ func (_IApplicationFactory *IApplicationFactoryFilterer) ParseApplicationCreated(log types.Log) (*IApplicationFactoryApplicationCreated, error)

+ func (_IApplicationFactory *IApplicationFactoryFilterer) WatchApplicationCreated(opts *bind.WatchOpts, sink chan<- *IApplicationFactoryApplicationCreated, ...) (event.Subscription, error)

+ type IApplicationFactoryRaw struct

+ Contract *IApplicationFactory

+ func (_IApplicationFactory *IApplicationFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_IApplicationFactory *IApplicationFactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IApplicationFactory *IApplicationFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IApplicationFactorySession struct

+ CallOpts bind.CallOpts

+ Contract *IApplicationFactory

+ TransactOpts bind.TransactOpts

+ func (_IApplicationFactory *IApplicationFactorySession) CalculateApplicationAddress(consensus common.Address, appOwner common.Address, templateHash [32]byte, ...) (common.Address, error)

+ func (_IApplicationFactory *IApplicationFactorySession) NewApplication(consensus common.Address, appOwner common.Address, templateHash [32]byte, ...) (*types.Transaction, error)

+ func (_IApplicationFactory *IApplicationFactorySession) NewApplication0(consensus common.Address, appOwner common.Address, templateHash [32]byte) (*types.Transaction, error)

+ type IApplicationFactoryTransactor struct

+ func NewIApplicationFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*IApplicationFactoryTransactor, error)

+ func (_IApplicationFactory *IApplicationFactoryTransactor) NewApplication(opts *bind.TransactOpts, consensus common.Address, appOwner common.Address, ...) (*types.Transaction, error)

+ func (_IApplicationFactory *IApplicationFactoryTransactor) NewApplication0(opts *bind.TransactOpts, consensus common.Address, appOwner common.Address, ...) (*types.Transaction, error)

+ type IApplicationFactoryTransactorRaw struct

+ Contract *IApplicationFactoryTransactor

+ func (_IApplicationFactory *IApplicationFactoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IApplicationFactory *IApplicationFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IApplicationFactoryTransactorSession struct

+ Contract *IApplicationFactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_IApplicationFactory *IApplicationFactoryTransactorSession) NewApplication(consensus common.Address, appOwner common.Address, templateHash [32]byte, ...) (*types.Transaction, error)

+ func (_IApplicationFactory *IApplicationFactoryTransactorSession) NewApplication0(consensus common.Address, appOwner common.Address, templateHash [32]byte) (*types.Transaction, error)

+ type IAuthorityFactory struct

+ func NewIAuthorityFactory(address common.Address, backend bind.ContractBackend) (*IAuthorityFactory, error)

+ type IAuthorityFactoryAuthorityCreated struct

+ Authority common.Address

+ Raw types.Log

+ type IAuthorityFactoryAuthorityCreatedIterator struct

+ Event *IAuthorityFactoryAuthorityCreated

+ func (it *IAuthorityFactoryAuthorityCreatedIterator) Close() error

+ func (it *IAuthorityFactoryAuthorityCreatedIterator) Error() error

+ func (it *IAuthorityFactoryAuthorityCreatedIterator) Next() bool

+ type IAuthorityFactoryCaller struct

+ func NewIAuthorityFactoryCaller(address common.Address, caller bind.ContractCaller) (*IAuthorityFactoryCaller, error)

+ func (_IAuthorityFactory *IAuthorityFactoryCaller) CalculateAuthorityAddress(opts *bind.CallOpts, authorityOwner common.Address, epochLength *big.Int, ...) (common.Address, error)

+ type IAuthorityFactoryCallerRaw struct

+ Contract *IAuthorityFactoryCaller

+ func (_IAuthorityFactory *IAuthorityFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type IAuthorityFactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IAuthorityFactoryCaller

+ func (_IAuthorityFactory *IAuthorityFactoryCallerSession) CalculateAuthorityAddress(authorityOwner common.Address, epochLength *big.Int, salt [32]byte) (common.Address, error)

+ type IAuthorityFactoryFilterer struct

+ func NewIAuthorityFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*IAuthorityFactoryFilterer, error)

+ func (_IAuthorityFactory *IAuthorityFactoryFilterer) FilterAuthorityCreated(opts *bind.FilterOpts) (*IAuthorityFactoryAuthorityCreatedIterator, error)

+ func (_IAuthorityFactory *IAuthorityFactoryFilterer) ParseAuthorityCreated(log types.Log) (*IAuthorityFactoryAuthorityCreated, error)

+ func (_IAuthorityFactory *IAuthorityFactoryFilterer) WatchAuthorityCreated(opts *bind.WatchOpts, sink chan<- *IAuthorityFactoryAuthorityCreated) (event.Subscription, error)

+ type IAuthorityFactoryRaw struct

+ Contract *IAuthorityFactory

+ func (_IAuthorityFactory *IAuthorityFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_IAuthorityFactory *IAuthorityFactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IAuthorityFactory *IAuthorityFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IAuthorityFactorySession struct

+ CallOpts bind.CallOpts

+ Contract *IAuthorityFactory

+ TransactOpts bind.TransactOpts

+ func (_IAuthorityFactory *IAuthorityFactorySession) CalculateAuthorityAddress(authorityOwner common.Address, epochLength *big.Int, salt [32]byte) (common.Address, error)

+ func (_IAuthorityFactory *IAuthorityFactorySession) NewAuthority(authorityOwner common.Address, epochLength *big.Int) (*types.Transaction, error)

+ func (_IAuthorityFactory *IAuthorityFactorySession) NewAuthority0(authorityOwner common.Address, epochLength *big.Int, salt [32]byte) (*types.Transaction, error)

+ type IAuthorityFactoryTransactor struct

+ func NewIAuthorityFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*IAuthorityFactoryTransactor, error)

+ func (_IAuthorityFactory *IAuthorityFactoryTransactor) NewAuthority(opts *bind.TransactOpts, authorityOwner common.Address, epochLength *big.Int) (*types.Transaction, error)

+ func (_IAuthorityFactory *IAuthorityFactoryTransactor) NewAuthority0(opts *bind.TransactOpts, authorityOwner common.Address, epochLength *big.Int, ...) (*types.Transaction, error)

+ type IAuthorityFactoryTransactorRaw struct

+ Contract *IAuthorityFactoryTransactor

+ func (_IAuthorityFactory *IAuthorityFactoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IAuthorityFactory *IAuthorityFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IAuthorityFactoryTransactorSession struct

+ Contract *IAuthorityFactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_IAuthorityFactory *IAuthorityFactoryTransactorSession) NewAuthority(authorityOwner common.Address, epochLength *big.Int) (*types.Transaction, error)

+ func (_IAuthorityFactory *IAuthorityFactoryTransactorSession) NewAuthority0(authorityOwner common.Address, epochLength *big.Int, salt [32]byte) (*types.Transaction, error)

+ type IConsensus struct

+ func NewIConsensus(address common.Address, backend bind.ContractBackend) (*IConsensus, error)

+ type IConsensusCaller struct

+ func NewIConsensusCaller(address common.Address, caller bind.ContractCaller) (*IConsensusCaller, error)

+ func (_IConsensus *IConsensusCaller) GetEpochLength(opts *bind.CallOpts) (*big.Int, error)

+ func (_IConsensus *IConsensusCaller) WasClaimAccepted(opts *bind.CallOpts, appContract common.Address, claim [32]byte) (bool, error)

+ type IConsensusCallerRaw struct

+ Contract *IConsensusCaller

+ func (_IConsensus *IConsensusCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type IConsensusCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IConsensusCaller

+ func (_IConsensus *IConsensusCallerSession) GetEpochLength() (*big.Int, error)

+ func (_IConsensus *IConsensusCallerSession) WasClaimAccepted(appContract common.Address, claim [32]byte) (bool, error)

+ type IConsensusClaimAcceptance struct

+ AppContract common.Address

+ Claim [32]byte

+ LastProcessedBlockNumber *big.Int

+ Raw types.Log

+ type IConsensusClaimAcceptanceIterator struct

+ Event *IConsensusClaimAcceptance

+ func (it *IConsensusClaimAcceptanceIterator) Close() error

+ func (it *IConsensusClaimAcceptanceIterator) Error() error

+ func (it *IConsensusClaimAcceptanceIterator) Next() bool

+ type IConsensusClaimSubmission struct

+ AppContract common.Address

+ Claim [32]byte

+ LastProcessedBlockNumber *big.Int

+ Raw types.Log

+ Submitter common.Address

+ type IConsensusClaimSubmissionIterator struct

+ Event *IConsensusClaimSubmission

+ func (it *IConsensusClaimSubmissionIterator) Close() error

+ func (it *IConsensusClaimSubmissionIterator) Error() error

+ func (it *IConsensusClaimSubmissionIterator) Next() bool

+ type IConsensusFilterer struct

+ func NewIConsensusFilterer(address common.Address, filterer bind.ContractFilterer) (*IConsensusFilterer, error)

+ func (_IConsensus *IConsensusFilterer) FilterClaimAcceptance(opts *bind.FilterOpts, appContract []common.Address) (*IConsensusClaimAcceptanceIterator, error)

+ func (_IConsensus *IConsensusFilterer) FilterClaimSubmission(opts *bind.FilterOpts, submitter []common.Address, ...) (*IConsensusClaimSubmissionIterator, error)

+ func (_IConsensus *IConsensusFilterer) ParseClaimAcceptance(log types.Log) (*IConsensusClaimAcceptance, error)

+ func (_IConsensus *IConsensusFilterer) ParseClaimSubmission(log types.Log) (*IConsensusClaimSubmission, error)

+ func (_IConsensus *IConsensusFilterer) WatchClaimAcceptance(opts *bind.WatchOpts, sink chan<- *IConsensusClaimAcceptance, ...) (event.Subscription, error)

+ func (_IConsensus *IConsensusFilterer) WatchClaimSubmission(opts *bind.WatchOpts, sink chan<- *IConsensusClaimSubmission, ...) (event.Subscription, error)

+ type IConsensusRaw struct

+ Contract *IConsensus

+ func (_IConsensus *IConsensusRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_IConsensus *IConsensusRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IConsensus *IConsensusRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IConsensusSession struct

+ CallOpts bind.CallOpts

+ Contract *IConsensus

+ TransactOpts bind.TransactOpts

+ func (_IConsensus *IConsensusSession) GetEpochLength() (*big.Int, error)

+ func (_IConsensus *IConsensusSession) SubmitClaim(appContract common.Address, lastProcessedBlockNumber *big.Int, claim [32]byte) (*types.Transaction, error)

+ func (_IConsensus *IConsensusSession) WasClaimAccepted(appContract common.Address, claim [32]byte) (bool, error)

+ type IConsensusTransactor struct

+ func NewIConsensusTransactor(address common.Address, transactor bind.ContractTransactor) (*IConsensusTransactor, error)

+ func (_IConsensus *IConsensusTransactor) SubmitClaim(opts *bind.TransactOpts, appContract common.Address, ...) (*types.Transaction, error)

+ type IConsensusTransactorRaw struct

+ Contract *IConsensusTransactor

+ func (_IConsensus *IConsensusTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IConsensus *IConsensusTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IConsensusTransactorSession struct

+ Contract *IConsensusTransactor

+ TransactOpts bind.TransactOpts

+ func (_IConsensus *IConsensusTransactorSession) SubmitClaim(appContract common.Address, lastProcessedBlockNumber *big.Int, claim [32]byte) (*types.Transaction, error)

+ type InputBox struct

+ func NewInputBox(address common.Address, backend bind.ContractBackend) (*InputBox, error)

+ type InputBoxCaller struct

+ func NewInputBoxCaller(address common.Address, caller bind.ContractCaller) (*InputBoxCaller, error)

+ func (_InputBox *InputBoxCaller) GetInputHash(opts *bind.CallOpts, appContract common.Address, index *big.Int) ([32]byte, error)

+ func (_InputBox *InputBoxCaller) GetNumberOfInputs(opts *bind.CallOpts, appContract common.Address) (*big.Int, error)

+ type InputBoxCallerRaw struct

+ Contract *InputBoxCaller

+ func (_InputBox *InputBoxCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type InputBoxCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InputBoxCaller

+ func (_InputBox *InputBoxCallerSession) GetInputHash(appContract common.Address, index *big.Int) ([32]byte, error)

+ func (_InputBox *InputBoxCallerSession) GetNumberOfInputs(appContract common.Address) (*big.Int, error)

+ type InputBoxFilterer struct

+ func NewInputBoxFilterer(address common.Address, filterer bind.ContractFilterer) (*InputBoxFilterer, error)

+ func (_InputBox *InputBoxFilterer) FilterInputAdded(opts *bind.FilterOpts, appContract []common.Address, index []*big.Int) (*InputBoxInputAddedIterator, error)

+ func (_InputBox *InputBoxFilterer) ParseInputAdded(log types.Log) (*InputBoxInputAdded, error)

+ func (_InputBox *InputBoxFilterer) WatchInputAdded(opts *bind.WatchOpts, sink chan<- *InputBoxInputAdded, ...) (event.Subscription, error)

+ type InputBoxInputAdded struct

+ AppContract common.Address

+ Index *big.Int

+ Input []byte

+ Raw types.Log

+ type InputBoxInputAddedIterator struct

+ Event *InputBoxInputAdded

+ func (it *InputBoxInputAddedIterator) Close() error

+ func (it *InputBoxInputAddedIterator) Error() error

+ func (it *InputBoxInputAddedIterator) Next() bool

+ type InputBoxRaw struct

+ Contract *InputBox

+ func (_InputBox *InputBoxRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_InputBox *InputBoxRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_InputBox *InputBoxRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InputBoxSession struct

+ CallOpts bind.CallOpts

+ Contract *InputBox

+ TransactOpts bind.TransactOpts

+ func (_InputBox *InputBoxSession) AddInput(appContract common.Address, payload []byte) (*types.Transaction, error)

+ func (_InputBox *InputBoxSession) GetInputHash(appContract common.Address, index *big.Int) ([32]byte, error)

+ func (_InputBox *InputBoxSession) GetNumberOfInputs(appContract common.Address) (*big.Int, error)

+ type InputBoxTransactor struct

+ func NewInputBoxTransactor(address common.Address, transactor bind.ContractTransactor) (*InputBoxTransactor, error)

+ func (_InputBox *InputBoxTransactor) AddInput(opts *bind.TransactOpts, appContract common.Address, payload []byte) (*types.Transaction, error)

+ type InputBoxTransactorRaw struct

+ Contract *InputBoxTransactor

+ func (_InputBox *InputBoxTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_InputBox *InputBoxTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InputBoxTransactorSession struct

+ Contract *InputBoxTransactor

+ TransactOpts bind.TransactOpts

+ func (_InputBox *InputBoxTransactorSession) AddInput(appContract common.Address, payload []byte) (*types.Transaction, error)

+ type Inputs struct

+ func NewInputs(address common.Address, backend bind.ContractBackend) (*Inputs, error)

+ type InputsCaller struct

+ func NewInputsCaller(address common.Address, caller bind.ContractCaller) (*InputsCaller, error)

+ type InputsCallerRaw struct

+ Contract *InputsCaller

+ func (_Inputs *InputsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type InputsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InputsCaller

+ type InputsFilterer struct

+ func NewInputsFilterer(address common.Address, filterer bind.ContractFilterer) (*InputsFilterer, error)

+ type InputsRaw struct

+ Contract *Inputs

+ func (_Inputs *InputsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Inputs *InputsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Inputs *InputsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InputsSession struct

+ CallOpts bind.CallOpts

+ Contract *Inputs

+ TransactOpts bind.TransactOpts

+ func (_Inputs *InputsSession) EvmAdvance(chainId *big.Int, appContract common.Address, msgSender common.Address, ...) (*types.Transaction, error)

+ type InputsTransactor struct

+ func NewInputsTransactor(address common.Address, transactor bind.ContractTransactor) (*InputsTransactor, error)

+ func (_Inputs *InputsTransactor) EvmAdvance(opts *bind.TransactOpts, chainId *big.Int, appContract common.Address, ...) (*types.Transaction, error)

+ type InputsTransactorRaw struct

+ Contract *InputsTransactor

+ func (_Inputs *InputsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Inputs *InputsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InputsTransactorSession struct

+ Contract *InputsTransactor

+ TransactOpts bind.TransactOpts

+ func (_Inputs *InputsTransactorSession) EvmAdvance(chainId *big.Int, appContract common.Address, msgSender common.Address, ...) (*types.Transaction, error)

+ type OutputValidityProof struct

+ OutputHashesSiblings [][32]byte

+ OutputIndex uint64

+ type Outputs struct

+ func NewOutputs(address common.Address, backend bind.ContractBackend) (*Outputs, error)

+ type OutputsCaller struct

+ func NewOutputsCaller(address common.Address, caller bind.ContractCaller) (*OutputsCaller, error)

+ type OutputsCallerRaw struct

+ Contract *OutputsCaller

+ func (_Outputs *OutputsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OutputsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OutputsCaller

+ type OutputsFilterer struct

+ func NewOutputsFilterer(address common.Address, filterer bind.ContractFilterer) (*OutputsFilterer, error)

+ type OutputsRaw struct

+ Contract *Outputs

+ func (_Outputs *OutputsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Outputs *OutputsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Outputs *OutputsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OutputsSession struct

+ CallOpts bind.CallOpts

+ Contract *Outputs

+ TransactOpts bind.TransactOpts

+ func (_Outputs *OutputsSession) DelegateCallVoucher(destination common.Address, payload []byte) (*types.Transaction, error)

+ func (_Outputs *OutputsSession) Notice(payload []byte) (*types.Transaction, error)

+ func (_Outputs *OutputsSession) Voucher(destination common.Address, value *big.Int, payload []byte) (*types.Transaction, error)

+ type OutputsTransactor struct

+ func NewOutputsTransactor(address common.Address, transactor bind.ContractTransactor) (*OutputsTransactor, error)

+ func (_Outputs *OutputsTransactor) DelegateCallVoucher(opts *bind.TransactOpts, destination common.Address, payload []byte) (*types.Transaction, error)

+ func (_Outputs *OutputsTransactor) Notice(opts *bind.TransactOpts, payload []byte) (*types.Transaction, error)

+ func (_Outputs *OutputsTransactor) Voucher(opts *bind.TransactOpts, destination common.Address, value *big.Int, ...) (*types.Transaction, error)

+ type OutputsTransactorRaw struct

+ Contract *OutputsTransactor

+ func (_Outputs *OutputsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Outputs *OutputsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OutputsTransactorSession struct

+ Contract *OutputsTransactor

+ TransactOpts bind.TransactOpts

+ func (_Outputs *OutputsTransactorSession) DelegateCallVoucher(destination common.Address, payload []byte) (*types.Transaction, error)

+ func (_Outputs *OutputsTransactorSession) Notice(payload []byte) (*types.Transaction, error)

+ func (_Outputs *OutputsTransactorSession) Voucher(destination common.Address, value *big.Int, payload []byte) (*types.Transaction, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL