Struct pallet_plasma::Module

pub struct Module<T: Config>(_);

Implementations

impl<T: Config> Module<T>

pub fn bare_exit_claim(
    plapps_id: &T::AccountId,
    state_update: &StateUpdateOf<T>,
    checkpoint: &Option<StateUpdateOf<T>>,
    witness: &Option<InclusionProofOf<T>>
) -> DispatchResult

Claim Exit at StateUpdate There’re two kind of exit claims. ExitStateUpdate and ExitCheckpoint. The former needs inclusion proof of stateUpdate. The latter don’t need witness but check if checkpoint for the stateUpdate is finalized yet. inputs: [encode(stateUpdate), checkpoint] witness: [encode(inclusionProof)]

pub fn bare_exit_challenge(
    plapps_id: &T::AccountId,
    state_update: &StateUpdateOf<T>,
    challenge_inputs: &Vec<Vec<u8>>,
    witness: &InclusionProofOf<T>
) -> DispatchResult

challenge prove the exiting coin has been spent. First element of challengeInputs must be either of bytes(“EXIT_SPENT_CHALLENGE”) or bytes(“EXIT_CHECKPOINT_CHALLENGE”) SPENT_CHALLENGE input: [SU] challengeInput: [label, transaction] witness: [signature] CHECKPOINT input: [SU] challengeInput: [label, checkpointSU] witness: []

pub fn bare_exit_remove_challenge(
    _plapps_id: &T::AccountId,
    _inputs: Vec<Vec<u8>>,
    _challenge_inputs: Vec<Vec<u8>>,
    _witness: Vec<Vec<u8>>
) -> DispatchResult

pub fn bare_exit_settle(
    plapps_id: &T::AccountId,
    state_update: &StateUpdateOf<T>
) -> DispatchResult

prove exit is coin which hasn’t been spent. check checkpoint

pub fn get_claim_decision(
    predicate_address: T::AccountId,
    su: &StateUpdateOf<T>
) -> DispatchResultT<Decision>

pub fn is_completable(plapps_id: &T::AccountId, su: &StateUpdateOf<T>) -> bool

If the exit can be withdrawable, isCompletable returns true.

impl<T: Config> Module<T>

pub fn create_property(
    predicate_address: T::AccountId,
    su_bytes: &Vec<u8>,
    kind: &'static [u8]
) -> PropertyOf<T>

impl<T: Config> Module<T>

pub fn validate_checkpoint_challenge(
    plapps_id: &T::AccountId,
    state_update: StateUpdateOf<T>,
    challenge_state_update: StateUpdateOf<T>,
    inclusion_proof: InclusionProofOf<T>
) -> DispatchResultT<(StateUpdateOf<T>, StateUpdateOf<T>, InclusionProofOf<T>)>

challenge checkpiont _inputs: [encode(stateUpdate)] challenged state update _challengeInputs: [encode(stateUpdate)] challenging state update _witness: [encode(inclusionProof)] inclusionProof of challenging state update

pub fn is_sub_range(
    sub_range: &RangeOf<T>,
    surrounding_range: &RangeOf<T>
) -> bool

pub fn has_intersection(range_a: &RangeOf<T>, range_b: &RangeOf<T>) -> bool

pub fn bytes_to_bytes32(source: Vec<u8>) -> DispatchResultT<T::Hash>

impl<T: Config + 'static> Module<T>

pub fn aggregator_address<K: EncodeLike<T::AccountId>>(key: K) -> T::AccountId

Single aggregator address: AggregatorId

pub fn current_block<K: EncodeLike<T::AccountId>>(key: K) -> T::BlockNumber

Current block number of commitment chain: BlockNumber

pub fn blocks<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> T::Hash where
    KArg1: EncodeLike<T::AccountId>,
    KArg2: EncodeLike<T::BlockNumber>, 

pub fn state_update_predicate<K: EncodeLike<T::AccountId>>(
    key: K
) -> T::AccountId

pub fn exit_predicate<K: EncodeLike<T::AccountId>>(key: K) -> T::AccountId

mapping from Plapps address to Exit predicate address.

pub fn exit_deposit_predicate<K: EncodeLike<T::AccountId>>(
    key: K
) -> T::AccountId

mapping from Plapps address to ExitDeposit predicate address.

pub fn total_deposited<K: EncodeLike<T::AccountId>>(key: K) -> BalanceOf<T>

TotalDeposited is the most right coin id which has been deposited.

pub fn deposited_ranges<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> RangeOf<T> where
    KArg1: EncodeLike<T::AccountId>,
    KArg2: EncodeLike<BalanceOf<T>>, 

pub fn checkpoints<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> bool where
    KArg1: EncodeLike<T::AccountId>,
    KArg2: EncodeLike<T::Hash>, 

pub fn payout<K: EncodeLike<T::AccountId>>(key: K) -> T::AccountId

predicate address => payout address

impl<T: Config> Module<T>

Public callable Plasma commitment module methods.

pub fn retrieve(
    plapps_id: &T::AccountId,
    block_number: &T::BlockNumber
) -> T::Hash

pub fn verify_inclusion(
    plapps_id: &T::AccountId,
    leaf: &T::Hash,
    token_address: &T::AccountId,
    range: &RangeOf<T>,
    inclusion_proof: &InclusionProofOf<T>,
    block_number: &T::BlockNumber
) -> DispatchResultT<bool>

verifyInclusion method verifies inclusion of message in Double Layer Tree. The message has range and token address and these also must be verified. Please see https://docs.plasma.group/projects/spec/en/latest/src/01-core/double-layer-tree.html for further details.

• @param leaf a message to verify its inclusion
• @param token_address token address of the message
• @param range range of the message
• @param inclusion_proof The proof data to verify inclusion
• @param block_number block number where the Merkle root is stored

pub fn verify_inclusion_with_root(
    leaf: &T::Hash,
    token_address: &T::AccountId,
    range: &RangeOf<T>,
    inclusion_proof: &InclusionProofOf<T>,
    root: &T::Hash
) -> DispatchResultT<bool>

impl<T: Config> Module<T>

Public callable Plasma deposit module methods.

pub fn bare_extend_deposited_ranges(
    plapps_id: &T::AccountId,
    amount: BalanceOf<T>
)

pub fn bare_remove_deposited_range(
    plapps_id: &T::AccountId,
    range: &RangeOf<T>,
    deposited_range_id: &BalanceOf<T>
) -> DispatchResult

pub fn bare_finalize_exit(
    plapps_id: &T::AccountId,
    exit_property: &PropertyOf<T>,
    deposited_range_id: &BalanceOf<T>
) -> DispatchResultT<StateUpdateOf<T>>

bare_finalize_exit called by this module.

• @param _exitProperty A property which is instance of exit predicate and its inputs are range and StateUpdate that exiting account wants to withdraw. _exitProperty can be a property of ether ExitPredicate or ExitDepositPredicate.
• @param _depositedRangeId Id of deposited range
• @return return StateUpdate of exit property which is finalized.
• @dev The steps of finalizeExit.

1. Serialize exit property
2. check the property is decided by Adjudication Contract.
3. Transfer asset to payout contract corresponding to StateObject.

Please alse see https://docs.plasma.group/projects/spec/en/latest/src/02-contracts/deposit-contract.html#finalizeexit

pub fn verify_exit_property(
    plapps_id: &T::AccountId,
    exit_property: &PropertyOf<T>
) -> DispatchResultT<StateUpdateOf<T>>

@dev verify StateUpdate in Exit property. _exitProperty must be instance of ether ExitPredicate or ExitDepositPredicate. if _exitProperty is instance of ExitDepositPredicate, check _exitProperty.su is subrange of _exitProperty.checkpoint.

Trait Implementations

impl<T: Config> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Config> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Config> Debug for Module<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Config> GetPalletVersion for Module<T>

fn current_version() -> PalletVersion

Returns the current version of the pallet.

fn storage_version() -> Option<PalletVersion>

Returns the version of the pallet that is stored in storage.

impl<T: Config> IntegrityTest for Module<T>

fn integrity_test()

Run integrity test.

impl<T: Config> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Config + Config> OffchainWorker<<T as Config>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Config + Config> OnFinalize<<T as Config>::BlockNumber> for Module<T>

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Config> OnGenesis for Module<T>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config + Config> OnInitialize<<T as Config>::BlockNumber> for Module<T>

fn on_initialize(_n: BlockNumber) -> u64

The block is being initialized. Implement to have something happen.

impl<T: Config> OnRuntimeUpgrade for Module<T>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

impl<T: PartialEq + Config> PartialEq<Module<T>> for Module<T>

fn eq(&self, other: &Module<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Copy + Config> Copy for Module<T>

impl<T: Eq + Config> Eq for Module<T>

impl<T: Config> StructuralEq for Module<T>

impl<T: Config> StructuralPartialEq for Module<T>