Struct PGasDeposit 

pub struct PGasDeposit<T, Mutator, Holder, Freezer, Id, RefundPercent>(/* private fields */);

PGAS-backed payment backend. Charges prefer PGAS and fall back to the native currency; refunds return native first (capped by [NativeDepositOf]) then RefundPercent of the PGAS portion, burning the rest.

Trait Implementations

impl<T, Mutator, Holder, Freezer, Id, RefundPercent> Deposit<T> for PGasDeposit<T, Mutator, Holder, Freezer, Id, RefundPercent>

where T: Config, Mutator: Mutate<T::AccountId, Balance = BalanceOf<T>>, Holder: MutateHold<T::AccountId, Balance = BalanceOf<T>, AssetId = <Mutator as Inspect<T::AccountId>>::AssetId>, <Holder as InspectHold<T::AccountId>>::Reason: From<HoldReason>, Freezer: Mutate<T::AccountId, Balance = BalanceOf<T>, AssetId = <Mutator as Inspect<T::AccountId>>::AssetId>, <Freezer as Inspect<T::AccountId>>::Id: From<FreezeReason>, Id: Get<<Mutator as Inspect<T::AccountId>>::AssetId>, RefundPercent: Get<Perbill>,

fn init_contract(to: &T::AccountId) -> DispatchResult

Mints one native ED and one PGAS ED into to, so the account can subsequently receive deposits in either asset without tripping existential-deposit checks. The minted native ED is deactivated so it stays outside active issuance. The minted PGAS ED is frozen under FreezeReason::PGasMinBalance so the contract cannot transfer or burn it: pallet-assets’ reducible_balance treats any frozen amount as untouchable, regardless of Preservation / Fortitude.

fn destroy_contract(contract: &T::AccountId) -> DispatchResult

Thaws and burns the PGAS ED frozen by Self::init_contract, plus the native ED.

fn charge_and_hold( reason: HoldReason, src: Funds<'_, T::AccountId>, to: &T::AccountId, amount: BalanceOf<T>, ) -> DispatchResult

Charges a deposit and places it on hold.

Uses PGAS when the payer has enough reducible PGAS, otherwise falls back to the native currency and records the contribution in [NativeDepositOf] so refunds return native up to the contributed amount. The native fallback honours [Funds::TxFee] by withdrawing from the txfee pool instead of the payer’s free balance.

fn refund_on_hold( reason: HoldReason, from: &T::AccountId, dst: Funds<'_, T::AccountId>, amount: BalanceOf<T>, ) -> DispatchResult

Refunds native currency first (capped by [NativeDepositOf]); any shortfall is taken from PGAS with RefundPercent refunded and the rest burned. When dst is [Funds::TxFee], the native portion is routed into the tx fee pool instead of the embedded account’s free balance. The PGAS portion (if any) is always settled to the account embedded in dst.

Note: callers must run inside a storage layer so partial state rolls back on error.

fn total_on_hold(reason: HoldReason, who: &T::AccountId) -> BalanceOf<T>

Sum of who’s native and PGAS balances on hold for reason.

fn refund_all( from: &T::AccountId, dst: Funds<'_, T::AccountId>, ) -> Result<BalanceOf<T>, DispatchError>

Refunds the full native hold to dst ignoring the per-contributor cap, then settles the PGAS hold via Self::settle_pgas_refund (refunding RefundPercent to dst and burning the rest). The native cap only makes sense for partial refunds on a live contract; at termination there is one recipient and the contract is gone.

Note: callers must run inside a storage layer so partial state rolls back on error.

fn migrate_native_to_pgas( reason: HoldReason, contract: &T::AccountId, amount: BalanceOf<T>, ) -> DispatchResult

Bring a pre-existing contract up to the post-Self::init_contract invariant: mint and freeze the PGAS ED if missing, then burn the native hold under reason and replace it with the same amount of PGAS held on contract.

const SUPPORTS_PGAS: bool = true

Whether this backend supports PGAS.