Struct cw_multi_test::ContractWrapper[−][src]

pub struct ContractWrapper<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> where
    T1: DeserializeOwned,
    T2: DeserializeOwned,
    T3: DeserializeOwned,
    T4: DeserializeOwned,
    E1: Display,
    E2: Display,
    E3: Display,
    E4: Display,
    C: Clone + Debug + PartialEq + JsonSchema,  { /* fields omitted */ }

Wraps the exported functions from a contract and provides the normalized format Place T4 and E4 at the end, as we just want default placeholders for most contracts that don’t have sudo

Implementations

`impl<T1, T2, T3, E1, E2, E3, C> ContractWrapper<T1, T2, T3, E1, E2, E3, C> where T1: DeserializeOwned + 'static, T2: DeserializeOwned + 'static, T3: DeserializeOwned + 'static, E1: Display + 'static, E2: Display + 'static, E3: Display + 'static, C: Clone + Debug + PartialEq + JsonSchema + 'static,` [src]

`pub fn new( handle_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T1) -> Result<Response<C>, E1>, init_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T2) -> Result<Response<C>, E2>, query_fn: fn(deps: Deps<'_>, env: Env, msg: T3) -> Result<Binary, E3> ) -> Self`[src]

`pub fn new_with_empty( handle_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T1) -> Result<Response<Empty>, E1>, init_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T2) -> Result<Response<Empty>, E2>, query_fn: fn(deps: Deps<'_>, env: Env, msg: T3) -> Result<Binary, E3> ) -> Self`[src]

this will take a contract that returns Response and will “upgrade” it to Response if needed to be compatible with a chain-specific extension

`impl<T1, T2, T3, E1, E2, E3, C, T4, E4> ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4> where T1: DeserializeOwned + 'static, T2: DeserializeOwned + 'static, T3: DeserializeOwned + 'static, T4: DeserializeOwned + 'static, E1: Display + 'static, E2: Display + 'static, E3: Display + 'static, E4: Display + 'static, C: Clone + Debug + PartialEq + JsonSchema + 'static,` [src]

`pub fn new_with_sudo( handle_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T1) -> Result<Response<C>, E1>, init_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T2) -> Result<Response<C>, E2>, query_fn: fn(deps: Deps<'_>, env: Env, msg: T3) -> Result<Binary, E3>, sudo_fn: fn(deps: DepsMut<'_>, env: Env, msg: T4) -> Result<Response<C>, E4> ) -> Self`[src]

Trait Implementations

`impl<T1, T2, T3, E1, E2, E3, C, T4, E4> Contract<C> for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4> where T1: DeserializeOwned, T2: DeserializeOwned, T3: DeserializeOwned, T4: DeserializeOwned, E1: Display, E2: Display, E3: Display, E4: Display, C: Clone + Debug + PartialEq + JsonSchema,` [src]

`fn handle( &self, deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: Vec<u8> ) -> Result<Response<C>, String>`[src]

`fn init( &self, deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: Vec<u8> ) -> Result<Response<C>, String>`[src]

`fn sudo( &self, deps: DepsMut<'_>, env: Env, msg: Vec<u8> ) -> Result<Response<C>, String>`[src]

`fn query( &self, deps: Deps<'_>, env: Env, msg: Vec<u8> ) -> Result<Binary, String>`[src]

Auto Trait Implementations

`impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !RefUnwindSafe for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>`

`impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !Send for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>`

`impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !Sync for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>`

`impl<T1, T2, T3, E1, E2, E3, C, T4, E4> Unpin for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>`

`impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !UnwindSafe for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: AsMut<T>, T: 'a, R: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where Self: Deref, R: 'a,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where Self: DerefMut, R: 'a,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> Tap for T`

`pub fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef for T where U: ?Sized,`

`pub fn tap_ref<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_mut<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T, U> TapBorrow for T where U: ?Sized,`

`pub fn tap_borrow<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T> TapDeref for T`

`pub fn tap_deref<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_mut<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

Struct cw_multi_test::ContractWrapper[−][src]

Implementations

pub fn new( handle_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T1) -> Result<Response<C>, E1>, init_fn: fn(deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: T2) -> Result<Response<C>, E2>, query_fn: fn(deps: Deps<'_>, env: Env, msg: T3) -> Result<Binary, E3>) -> Self[src]

Trait Implementations

fn handle( &self, deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: Vec<u8>) -> Result<Response<C>, String>[src]

fn init( &self, deps: DepsMut<'_>, env: Env, info: MessageInfo, msg: Vec<u8>) -> Result<Response<C>, String>[src]

fn sudo( &self, deps: DepsMut<'_>, env: Env, msg: Vec<u8>) -> Result<Response<C>, String>[src]

fn query( &self, deps: Deps<'_>, env: Env, msg: Vec<u8>) -> Result<Binary, String>[src]

Auto Trait Implementations

impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !RefUnwindSafe for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>

impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !Send for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>

impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !Sync for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>

impl<T1, T2, T3, E1, E2, E3, C, T4, E4> Unpin for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>

impl<T1, T2, T3, E1, E2, E3, C = Empty, T4 = String, E4 = String> !UnwindSafe for ContractWrapper<T1, T2, T3, E1, E2, E3, C, T4, E4>

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> FmtForward for T

pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<T> Pipe for T

pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

impl<T> PipeAsRef for T

pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,

pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: AsMut<T>, T: 'a, R: 'a,

impl<T> PipeBorrow for T

pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,

pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,

impl<T> PipeDeref for T

pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where Self: Deref, R: 'a,

pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R) -> R where Self: DerefMut, R: 'a,

impl<T> PipeRef for T

pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,

pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,

impl<T> Same<T> for T

type Output = T

impl<T> Tap for T

pub fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,

pub fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,

pub fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,

pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,

impl<T, U> TapAsRef<U> for T where U: ?Sized,

pub fn tap_ref<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,

pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,

pub fn tap_ref_mut<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,

pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,

impl<T, U> TapBorrow<U> for T where U: ?Sized,

pub fn tap_borrow<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,

pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,

pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,

pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,

impl<T> TapDeref for T

pub fn tap_deref<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,

pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,

pub fn tap_deref_mut<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,

pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,

impl<T> TryConv for T

pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]