#![allow(clippy::new_ret_no_self)]
use crate::{
serde_hex,
utils::trim_extra_whitespace,
};
#[cfg(not(feature = "std"))]
use alloc::{
format,
vec,
vec::Vec,
};
use core::marker::PhantomData;
use scale_info::{
form::{
Form,
MetaForm,
PortableForm,
},
meta_type,
IntoPortable,
Registry,
TypeInfo,
};
use serde::{
de::DeserializeOwned,
Deserialize,
Serialize,
};
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
))]
pub struct ContractSpec<F: Form = MetaForm> {
constructors: Vec<ConstructorSpec<F>>,
messages: Vec<MessageSpec<F>>,
events: Vec<EventSpec<F>>,
docs: Vec<F::String>,
lang_error: TypeSpec<F>,
}
impl IntoPortable for ContractSpec {
type Output = ContractSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
ContractSpec {
constructors: self
.constructors
.into_iter()
.map(|constructor| constructor.into_portable(registry))
.collect::<Vec<_>>(),
messages: self
.messages
.into_iter()
.map(|msg| msg.into_portable(registry))
.collect::<Vec<_>>(),
events: self
.events
.into_iter()
.map(|event| event.into_portable(registry))
.collect::<Vec<_>>(),
docs: registry.map_into_portable(self.docs),
lang_error: self.lang_error.into_portable(registry),
}
}
}
impl<F> ContractSpec<F>
where
F: Form,
{
pub fn constructors(&self) -> &[ConstructorSpec<F>] {
&self.constructors
}
pub fn messages(&self) -> &[MessageSpec<F>] {
&self.messages
}
pub fn events(&self) -> &[EventSpec<F>] {
&self.events
}
pub fn docs(&self) -> &[F::String] {
&self.docs
}
pub fn lang_error(&self) -> &TypeSpec<F> {
&self.lang_error
}
}
pub enum Valid {}
pub enum Invalid {}
#[must_use]
pub struct ContractSpecBuilder<F, S = Invalid>
where
F: Form,
{
spec: ContractSpec<F>,
marker: PhantomData<fn() -> S>,
}
impl<F> ContractSpecBuilder<F, Invalid>
where
F: Form,
{
pub fn constructors<C>(self, constructors: C) -> ContractSpecBuilder<F, Valid>
where
C: IntoIterator<Item = ConstructorSpec<F>>,
{
debug_assert!(self.spec.constructors.is_empty());
ContractSpecBuilder {
spec: ContractSpec {
constructors: constructors.into_iter().collect::<Vec<_>>(),
..self.spec
},
marker: Default::default(),
}
}
}
impl<F, S> ContractSpecBuilder<F, S>
where
F: Form,
{
pub fn messages<M>(self, messages: M) -> Self
where
M: IntoIterator<Item = MessageSpec<F>>,
{
debug_assert!(self.spec.messages.is_empty());
Self {
spec: ContractSpec {
messages: messages.into_iter().collect::<Vec<_>>(),
..self.spec
},
..self
}
}
pub fn events<E>(self, events: E) -> Self
where
E: IntoIterator<Item = EventSpec<F>>,
{
debug_assert!(self.spec.events.is_empty());
Self {
spec: ContractSpec {
events: events.into_iter().collect::<Vec<_>>(),
..self.spec
},
..self
}
}
pub fn docs<D>(self, docs: D) -> Self
where
D: IntoIterator<Item = <F as Form>::String>,
{
debug_assert!(self.spec.docs.is_empty());
Self {
spec: ContractSpec {
docs: docs.into_iter().collect::<Vec<_>>(),
..self.spec
},
..self
}
}
pub fn lang_error(self, lang_error: TypeSpec<F>) -> Self {
Self {
spec: ContractSpec {
lang_error,
..self.spec
},
..self
}
}
}
impl<F> ContractSpecBuilder<F, Valid>
where
F: Form,
{
pub fn done(self) -> ContractSpec<F> {
assert!(
!self.spec.constructors.is_empty(),
"must have at least one constructor"
);
assert!(
!self.spec.messages.is_empty(),
"must have at least one message"
);
self.spec
}
}
impl<F> ContractSpec<F>
where
F: Form,
TypeSpec<F>: Default,
{
pub fn new() -> ContractSpecBuilder<F, Invalid> {
ContractSpecBuilder {
spec: Self {
constructors: Vec::new(),
messages: Vec::new(),
events: Vec::new(),
docs: Vec::new(),
lang_error: Default::default(),
},
marker: PhantomData,
}
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned",
))]
#[serde(rename_all = "camelCase")]
pub struct ConstructorSpec<F: Form = MetaForm> {
pub label: F::String,
pub selector: Selector,
pub payable: bool,
pub args: Vec<MessageParamSpec<F>>,
pub return_type: ReturnTypeSpec<F>,
pub docs: Vec<F::String>,
}
impl IntoPortable for ConstructorSpec {
type Output = ConstructorSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
ConstructorSpec {
label: self.label.to_string(),
selector: self.selector,
payable: self.payable,
args: self
.args
.into_iter()
.map(|arg| arg.into_portable(registry))
.collect::<Vec<_>>(),
return_type: self.return_type.into_portable(registry),
docs: self.docs.into_iter().map(|s| s.into()).collect(),
}
}
}
impl<F> ConstructorSpec<F>
where
F: Form,
{
pub fn label(&self) -> &F::String {
&self.label
}
pub fn selector(&self) -> &Selector {
&self.selector
}
pub fn payable(&self) -> &bool {
&self.payable
}
pub fn args(&self) -> &[MessageParamSpec<F>] {
&self.args
}
pub fn return_type(&self) -> &ReturnTypeSpec<F> {
&self.return_type
}
pub fn docs(&self) -> &[F::String] {
&self.docs
}
}
#[allow(clippy::type_complexity)]
#[must_use]
pub struct ConstructorSpecBuilder<F: Form, Selector, IsPayable, Returns> {
spec: ConstructorSpec<F>,
marker: PhantomData<fn() -> (Selector, IsPayable, Returns)>,
}
impl<F> ConstructorSpec<F>
where
F: Form,
{
pub fn from_label(
label: <F as Form>::String,
) -> ConstructorSpecBuilder<
F,
Missing<state::Selector>,
Missing<state::IsPayable>,
Missing<state::Returns>,
> {
ConstructorSpecBuilder {
spec: Self {
label,
selector: Selector::default(),
payable: Default::default(),
args: Vec::new(),
return_type: ReturnTypeSpec::new(None),
docs: Vec::new(),
},
marker: PhantomData,
}
}
}
impl<F, P, R> ConstructorSpecBuilder<F, Missing<state::Selector>, P, R>
where
F: Form,
{
pub fn selector(
self,
selector: [u8; 4],
) -> ConstructorSpecBuilder<F, state::Selector, P, R> {
ConstructorSpecBuilder {
spec: ConstructorSpec {
selector: selector.into(),
..self.spec
},
marker: PhantomData,
}
}
}
impl<F, S, R> ConstructorSpecBuilder<F, S, Missing<state::IsPayable>, R>
where
F: Form,
{
pub fn payable(
self,
is_payable: bool,
) -> ConstructorSpecBuilder<F, S, state::IsPayable, R> {
ConstructorSpecBuilder {
spec: ConstructorSpec {
payable: is_payable,
..self.spec
},
marker: PhantomData,
}
}
}
impl<F, S, P> ConstructorSpecBuilder<F, S, P, Missing<state::Returns>>
where
F: Form,
{
pub fn returns(
self,
return_type: ReturnTypeSpec<F>,
) -> ConstructorSpecBuilder<F, S, P, state::Returns> {
ConstructorSpecBuilder {
spec: ConstructorSpec {
return_type,
..self.spec
},
marker: PhantomData,
}
}
}
impl<F, S, P, R> ConstructorSpecBuilder<F, S, P, R>
where
F: Form,
{
pub fn args<A>(self, args: A) -> Self
where
A: IntoIterator<Item = MessageParamSpec<F>>,
{
let mut this = self;
debug_assert!(this.spec.args.is_empty());
this.spec.args = args.into_iter().collect::<Vec<_>>();
this
}
pub fn docs<'a, D>(self, docs: D) -> Self
where
D: IntoIterator<Item = &'a str>,
F::String: From<&'a str>,
{
let mut this = self;
debug_assert!(this.spec.docs.is_empty());
this.spec.docs = docs
.into_iter()
.map(|s| trim_extra_whitespace(s).into())
.collect::<Vec<_>>();
this
}
}
impl<F> ConstructorSpecBuilder<F, state::Selector, state::IsPayable, state::Returns>
where
F: Form,
{
pub fn done(self) -> ConstructorSpec<F> {
self.spec
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
))]
#[serde(rename_all = "camelCase")]
pub struct MessageSpec<F: Form = MetaForm> {
label: F::String,
selector: Selector,
mutates: bool,
payable: bool,
args: Vec<MessageParamSpec<F>>,
return_type: ReturnTypeSpec<F>,
docs: Vec<F::String>,
}
pub struct Missing<S>(PhantomData<fn() -> S>);
mod state {
pub struct Selector;
pub struct Mutates;
pub struct IsPayable;
pub struct Returns;
}
impl<F> MessageSpec<F>
where
F: Form,
{
pub fn from_label(
label: <F as Form>::String,
) -> MessageSpecBuilder<
F,
Missing<state::Selector>,
Missing<state::Mutates>,
Missing<state::IsPayable>,
Missing<state::Returns>,
> {
MessageSpecBuilder {
spec: Self {
label,
selector: Selector::default(),
mutates: false,
payable: false,
args: Vec::new(),
return_type: ReturnTypeSpec::new(None),
docs: Vec::new(),
},
marker: PhantomData,
}
}
}
impl<F> MessageSpec<F>
where
F: Form,
{
pub fn label(&self) -> &F::String {
&self.label
}
pub fn selector(&self) -> &Selector {
&self.selector
}
pub fn mutates(&self) -> bool {
self.mutates
}
pub fn payable(&self) -> bool {
self.payable
}
pub fn args(&self) -> &[MessageParamSpec<F>] {
&self.args
}
pub fn return_type(&self) -> &ReturnTypeSpec<F> {
&self.return_type
}
pub fn docs(&self) -> &[F::String] {
&self.docs
}
}
#[allow(clippy::type_complexity)]
#[must_use]
pub struct MessageSpecBuilder<F, Selector, Mutates, IsPayable, Returns>
where
F: Form,
{
spec: MessageSpec<F>,
marker: PhantomData<fn() -> (Selector, Mutates, IsPayable, Returns)>,
}
impl<F, M, P, R> MessageSpecBuilder<F, Missing<state::Selector>, M, P, R>
where
F: Form,
{
pub fn selector(
self,
selector: [u8; 4],
) -> MessageSpecBuilder<F, state::Selector, M, P, R> {
MessageSpecBuilder {
spec: MessageSpec {
selector: selector.into(),
..self.spec
},
marker: PhantomData,
}
}
}
impl<F, S, P, R> MessageSpecBuilder<F, S, Missing<state::Mutates>, P, R>
where
F: Form,
{
pub fn mutates(
self,
mutates: bool,
) -> MessageSpecBuilder<F, S, state::Mutates, P, R> {
MessageSpecBuilder {
spec: MessageSpec {
mutates,
..self.spec
},
marker: PhantomData,
}
}
}
impl<F, S, M, R> MessageSpecBuilder<F, S, M, Missing<state::IsPayable>, R>
where
F: Form,
{
pub fn payable(
self,
is_payable: bool,
) -> MessageSpecBuilder<F, S, M, state::IsPayable, R> {
MessageSpecBuilder {
spec: MessageSpec {
payable: is_payable,
..self.spec
},
marker: PhantomData,
}
}
}
impl<F, M, S, P> MessageSpecBuilder<F, S, M, P, Missing<state::Returns>>
where
F: Form,
{
pub fn returns(
self,
return_type: ReturnTypeSpec<F>,
) -> MessageSpecBuilder<F, S, M, P, state::Returns> {
MessageSpecBuilder {
spec: MessageSpec {
return_type,
..self.spec
},
marker: PhantomData,
}
}
}
impl<F, S, M, P, R> MessageSpecBuilder<F, S, M, P, R>
where
F: Form,
{
pub fn args<A>(self, args: A) -> Self
where
A: IntoIterator<Item = MessageParamSpec<F>>,
{
let mut this = self;
debug_assert!(this.spec.args.is_empty());
this.spec.args = args.into_iter().collect::<Vec<_>>();
this
}
pub fn docs<D>(self, docs: D) -> Self
where
D: IntoIterator<Item = <F as Form>::String>,
{
let mut this = self;
debug_assert!(this.spec.docs.is_empty());
this.spec.docs = docs.into_iter().collect::<Vec<_>>();
this
}
}
impl<F>
MessageSpecBuilder<
F,
state::Selector,
state::Mutates,
state::IsPayable,
state::Returns,
>
where
F: Form,
{
pub fn done(self) -> MessageSpec<F> {
self.spec
}
}
impl IntoPortable for MessageSpec {
type Output = MessageSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
MessageSpec {
label: self.label.to_string(),
selector: self.selector,
mutates: self.mutates,
payable: self.payable,
args: self
.args
.into_iter()
.map(|arg| arg.into_portable(registry))
.collect::<Vec<_>>(),
return_type: self.return_type.into_portable(registry),
docs: self.docs.into_iter().map(|s| s.into()).collect(),
}
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
))]
pub struct EventSpec<F: Form = MetaForm> {
label: F::String,
args: Vec<EventParamSpec<F>>,
docs: Vec<F::String>,
}
#[must_use]
pub struct EventSpecBuilder<F>
where
F: Form,
{
spec: EventSpec<F>,
}
impl<F> EventSpecBuilder<F>
where
F: Form,
{
pub fn args<A>(self, args: A) -> Self
where
A: IntoIterator<Item = EventParamSpec<F>>,
{
let mut this = self;
debug_assert!(this.spec.args.is_empty());
this.spec.args = args.into_iter().collect::<Vec<_>>();
this
}
pub fn docs<D>(self, docs: D) -> Self
where
D: IntoIterator<Item = <F as Form>::String>,
{
let mut this = self;
debug_assert!(this.spec.docs.is_empty());
this.spec.docs = docs.into_iter().collect::<Vec<_>>();
this
}
pub fn done(self) -> EventSpec<F> {
self.spec
}
}
impl IntoPortable for EventSpec {
type Output = EventSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
EventSpec {
label: self.label.to_string(),
args: self
.args
.into_iter()
.map(|arg| arg.into_portable(registry))
.collect::<Vec<_>>(),
docs: self.docs.into_iter().map(|s| s.into()).collect(),
}
}
}
impl<F> EventSpec<F>
where
F: Form,
{
pub fn new(label: <F as Form>::String) -> EventSpecBuilder<F> {
EventSpecBuilder {
spec: Self {
label,
args: Vec::new(),
docs: Vec::new(),
},
}
}
}
impl<F> EventSpec<F>
where
F: Form,
{
pub fn label(&self) -> &F::String {
&self.label
}
pub fn args(&self) -> &[EventParamSpec<F>] {
&self.args
}
pub fn docs(&self) -> &[F::String] {
&self.docs
}
}
#[derive(Debug, Default, PartialEq, Eq, derive_more::From)]
pub struct Selector([u8; 4]);
impl serde::Serialize for Selector {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serde_hex::serialize(&self.0, serializer)
}
}
impl<'de> serde::Deserialize<'de> for Selector {
fn deserialize<D>(d: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let mut arr = [0; 4];
serde_hex::deserialize_check_len(d, serde_hex::ExpectedLen::Exact(&mut arr[..]))?;
Ok(arr.into())
}
}
impl Selector {
pub fn new<T>(bytes: T) -> Self
where
T: Into<[u8; 4]>,
{
Self(bytes.into())
}
pub fn to_bytes(&self) -> &[u8] {
&self.0
}
}
pub type DisplayName<F> = scale_info::Path<F>;
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
))]
#[serde(rename_all = "camelCase")]
pub struct TypeSpec<F: Form = MetaForm> {
#[serde(rename = "type")]
ty: F::Type,
display_name: DisplayName<F>,
}
impl Default for TypeSpec<MetaForm> {
fn default() -> Self {
TypeSpec::of_type::<()>()
}
}
impl Default for TypeSpec<PortableForm> {
fn default() -> Self {
Self {
ty: u32::default().into(),
display_name: Default::default(),
}
}
}
impl IntoPortable for TypeSpec {
type Output = TypeSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
TypeSpec {
ty: registry.register_type(&self.ty),
display_name: self.display_name.into_portable(registry),
}
}
}
impl TypeSpec {
pub fn with_name_str<T>(display_name: &'static str) -> Self
where
T: TypeInfo + 'static,
{
Self::with_name_segs::<T, _>(display_name.split("::"))
}
pub fn with_name_segs<T, S>(segments: S) -> Self
where
T: TypeInfo + 'static,
S: IntoIterator<Item = &'static str>,
{
Self {
ty: meta_type::<T>(),
display_name: DisplayName::from_segments(segments)
.unwrap_or_else(|err| panic!("display name is invalid: {:?}", err)),
}
}
pub fn of_type<T>() -> Self
where
T: TypeInfo + 'static,
{
Self {
ty: meta_type::<T>(),
display_name: DisplayName::default(),
}
}
}
impl<F> TypeSpec<F>
where
F: Form,
{
pub fn ty(&self) -> &F::Type {
&self.ty
}
pub fn display_name(&self) -> &DisplayName<F> {
&self.display_name
}
pub fn new(ty: <F as Form>::Type, display_name: DisplayName<F>) -> Self {
Self { ty, display_name }
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
))]
pub struct EventParamSpec<F: Form = MetaForm> {
label: F::String,
indexed: bool,
#[serde(rename = "type")]
ty: TypeSpec<F>,
docs: Vec<F::String>,
}
impl IntoPortable for EventParamSpec {
type Output = EventParamSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
EventParamSpec {
label: self.label.to_string(),
indexed: self.indexed,
ty: self.ty.into_portable(registry),
docs: self.docs.into_iter().map(|s| s.into()).collect(),
}
}
}
impl<F> EventParamSpec<F>
where
F: Form,
TypeSpec<F>: Default,
{
pub fn new(label: F::String) -> EventParamSpecBuilder<F> {
EventParamSpecBuilder {
spec: Self {
label,
indexed: false,
ty: Default::default(),
docs: vec![],
},
}
}
pub fn label(&self) -> &F::String {
&self.label
}
pub fn indexed(&self) -> bool {
self.indexed
}
pub fn ty(&self) -> &TypeSpec<F> {
&self.ty
}
pub fn docs(&self) -> &[F::String] {
&self.docs
}
}
#[must_use]
pub struct EventParamSpecBuilder<F>
where
F: Form,
{
spec: EventParamSpec<F>,
}
impl<F> EventParamSpecBuilder<F>
where
F: Form,
{
pub fn of_type(self, spec: TypeSpec<F>) -> Self {
let mut this = self;
this.spec.ty = spec;
this
}
pub fn indexed(self, is_indexed: bool) -> Self {
let mut this = self;
this.spec.indexed = is_indexed;
this
}
pub fn docs<D>(self, docs: D) -> Self
where
D: IntoIterator<Item = <F as Form>::String>,
{
debug_assert!(self.spec.docs.is_empty());
Self {
spec: EventParamSpec {
docs: docs.into_iter().collect::<Vec<_>>(),
..self.spec
},
}
}
pub fn done(self) -> EventParamSpec<F> {
self.spec
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
))]
#[must_use]
pub struct ReturnTypeSpec<F: Form = MetaForm> {
#[serde(rename = "type")]
opt_type: Option<TypeSpec<F>>,
}
impl IntoPortable for ReturnTypeSpec {
type Output = ReturnTypeSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
ReturnTypeSpec {
opt_type: self
.opt_type
.map(|opt_type| opt_type.into_portable(registry)),
}
}
}
impl<F> ReturnTypeSpec<F>
where
F: Form,
{
pub fn new<T>(ty: T) -> Self
where
T: Into<Option<TypeSpec<F>>>,
{
Self {
opt_type: ty.into(),
}
}
pub fn opt_type(&self) -> Option<&TypeSpec<F>> {
self.opt_type.as_ref()
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "F::Type: Serialize, F::String: Serialize",
deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
))]
pub struct MessageParamSpec<F: Form = MetaForm> {
label: F::String,
#[serde(rename = "type")]
ty: TypeSpec<F>,
}
impl IntoPortable for MessageParamSpec {
type Output = MessageParamSpec<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
MessageParamSpec {
label: self.label.to_string(),
ty: self.ty.into_portable(registry),
}
}
}
impl<F> MessageParamSpec<F>
where
F: Form,
TypeSpec<F>: Default,
{
pub fn new(label: F::String) -> MessageParamSpecBuilder<F> {
MessageParamSpecBuilder {
spec: Self {
label,
ty: TypeSpec::default(),
},
}
}
pub fn label(&self) -> &F::String {
&self.label
}
pub fn ty(&self) -> &TypeSpec<F> {
&self.ty
}
}
#[must_use]
pub struct MessageParamSpecBuilder<F: Form> {
spec: MessageParamSpec<F>,
}
impl<F> MessageParamSpecBuilder<F>
where
F: Form,
{
pub fn of_type(self, ty: TypeSpec<F>) -> Self {
let mut this = self;
this.spec.ty = ty;
this
}
pub fn done(self) -> MessageParamSpec<F> {
self.spec
}
}