Rename clvm-derive representations (#316)

* Rename clvm-derive representations

* Missed one

* Rename tests

* Rename test fns

* Factor out assignment

chia-tools/src/bin/run-spend.rs

@@ -130,37 +130,37 @@ pub struct SingletonStruct {
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct SingletonArgs {
     pub singleton_struct: SingletonStruct,
     pub inner_puzzle: NodePtr,
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct LineageProof {
     pub parent_parent_coin_id: Bytes32,
     pub parent_inner_puzzle_hash: Bytes32,
     pub parent_amount: u64,
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct EveProof {
     pub parent_parent_coin_id: Bytes32,
     pub parent_amount: u64,
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct SingletonSolution {
     pub lineage_proof: LineageProof,
     pub amount: u64,
     pub inner_solution: NodePtr,
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct EveSingletonSolution {
     pub lineage_proof: EveProof,
     pub amount: u64,

chia-wallet/src/proof.rs

@@ -44,15 +44,15 @@ impl<'a> Arbitrary<'a> for Proof {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct LineageProof {
     pub parent_coin_info: [u8; 32],
     pub inner_puzzle_hash: [u8; 32],
     pub amount: u64,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct EveProof {
     pub parent_coin_info: [u8; 32],
     pub amount: u64,

chia-wallet/src/puzzles/cat.rs

@@ -7,21 +7,21 @@ use hex_literal::hex;
 use crate::LineageProof;
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct CatArgs {
     pub mod_hash: [u8; 32],
     pub tail_program_hash: [u8; 32],
     pub inner_puzzle: NodePtr,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct EverythingWithSignatureTailArgs {
     pub public_key: PublicKey,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct CatSolution {
     pub inner_puzzle_solution: NodePtr,
     pub lineage_proof: Option<LineageProof>,
@@ -33,7 +33,7 @@ pub struct CatSolution {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct CoinProof {
     pub parent_coin_info: [u8; 32],
     pub inner_puzzle_hash: [u8; 32],

chia-wallet/src/puzzles/did.rs

@@ -5,7 +5,7 @@ use hex_literal::hex;
 use crate::singleton::SingletonStruct;
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct DidArgs {
     pub inner_puzzle: NodePtr,
     pub recovery_did_list_hash: [u8; 32],

chia-wallet/src/puzzles/nft.rs

@@ -6,15 +6,15 @@ use hex_literal::hex;
 use crate::singleton::SingletonStruct;
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct NftIntermediateLauncherArgs {
     pub launcher_puzzle_hash: [u8; 32],
     pub mint_number: usize,
     pub mint_total: usize,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct NftStateLayerArgs {
     pub mod_hash: [u8; 32],
     pub metadata: NodePtr,
@@ -23,13 +23,13 @@ pub struct NftStateLayerArgs {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct NftStateLayerSolution {
     pub inner_solution: NodePtr,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct NftOwnershipLayerArgs {
     pub mod_hash: [u8; 32],
     pub current_owner: Option<[u8; 32]>,
@@ -38,13 +38,13 @@ pub struct NftOwnershipLayerArgs {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct NftOwnershipLayerSolution {
     pub inner_solution: NodePtr,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct NftRoyaltyTransferPuzzleArgs {
     pub singleton_struct: SingletonStruct,
     pub royalty_puzzle_hash: [u8; 32],

chia-wallet/src/puzzles/singleton.rs

@@ -5,7 +5,7 @@ use hex_literal::hex;
 use crate::Proof;
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct SingletonArgs {
     pub singleton_struct: SingletonStruct,
     pub inner_puzzle: NodePtr,
@@ -20,15 +20,15 @@ pub struct SingletonStruct {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct SingletonSolution {
     pub proof: Proof,
     pub amount: u64,
     pub inner_solution: NodePtr,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct LauncherSolution {
     pub singleton_puzzle_hash: [u8; 32],
     pub amount: u64,

chia-wallet/src/puzzles/standard.rs

@@ -5,13 +5,13 @@ use clvmr::allocator::NodePtr;
 use hex_literal::hex;
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct StandardArgs {
     pub synthetic_key: PublicKey,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct StandardSolution {
     pub original_public_key: Option<PublicKey>,
     pub delegated_puzzle: NodePtr,

clvm-derive/src/from_clvm.rs

@@ -43,15 +43,15 @@ pub fn from_clvm(mut ast: DeriveInput) -> TokenStream {
     // `match_macro` decodes a nested tuple containing each of the struct field types within.
     // `destructure_macro` destructures the values into the field names, to be stored in the struct.
     let (match_macro, destructure_macro) = match args.repr {
-        Repr::ProperList => (
+        Repr::List => (
             quote!( #crate_name::match_list ),
             quote!( #crate_name::destructure_list ),
         ),
         Repr::Tuple => (
             quote!( #crate_name::match_tuple ),
             quote!( #crate_name::destructure_tuple ),
         ),
-        Repr::CurriedArgs => (
+        Repr::Curry => (
             quote!( #crate_name::match_curried_args ),
             quote!( #crate_name::destructure_curried_args ),
         ),

clvm-derive/src/helpers.rs

@@ -1,20 +1,22 @@
+use std::fmt;
+
 use proc_macro2::Ident;
 use syn::{punctuated::Punctuated, Attribute, GenericParam, Generics, Token, TypeParamBound};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Repr {
     Tuple,
-    ProperList,
-    CurriedArgs,
+    List,
+    Curry,
 }
 
-impl ToString for Repr {
-    fn to_string(&self) -> String {
-        match self {
-            Self::Tuple => "tuple".to_string(),
-            Self::ProperList => "proper_list".to_string(),
-            Self::CurriedArgs => "curried_args".to_string(),
-        }
+impl fmt::Display for Repr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::Tuple => "tuple",
+            Self::List => "list",
+            Self::Curry => "curry",
+        })
     }
 }
 
@@ -23,8 +25,15 @@ pub struct ClvmDeriveArgs {
 }
 
 pub fn parse_args(attrs: &[Attribute]) -> ClvmDeriveArgs {
-    let mut repr: Option<Repr> = None;
+    let repr = parse_repr(attrs);
+    ClvmDeriveArgs {
+        repr: repr
+            .expect("expected clvm attribute parameter of either `tuple`, `list`, or `curry`"),
+    }
+}
 
+pub fn parse_repr(attrs: &[Attribute]) -> Option<Repr> {
+    let mut repr: Option<Repr> = None;
     for attr in attrs {
         if let Some(ident) = attr.path().get_ident() {
             if ident == "clvm" {
@@ -33,37 +42,23 @@ pub fn parse_args(attrs: &[Attribute]) -> ClvmDeriveArgs {
                     .unwrap();
 
                 for arg in args {
-                    match arg.to_string().as_str() {
-                        "tuple" => {
-                            if let Some(existing) = repr {
-                                panic!("`tuple` conflicts with `{}`", existing.to_string());
-                            }
-                            repr = Some(Repr::Tuple);
-                        }
-                        "proper_list" => {
-                            if let Some(existing) = repr {
-                                panic!("`proper_list` conflicts with `{}`", existing.to_string());
-                            }
-                            repr = Some(Repr::ProperList);
-                        }
-                        "curried_args" => {
-                            if let Some(existing) = repr {
-                                panic!("`curried_args` conflicts with `{}`", existing.to_string());
-                            }
-                            repr = Some(Repr::CurriedArgs);
-                        }
-                        ident => panic!("unknown argument `{}`", ident),
+                    let existing = repr;
+
+                    repr = Some(match arg.to_string().as_str() {
+                        "tuple" => Repr::Tuple,
+                        "list" => Repr::List,
+                        "curry" => Repr::Curry,
+                        ident => panic!("unknown argument `{ident}`"),
+                    });
+
+                    if let Some(existing) = existing {
+                        panic!("`{arg}` conflicts with `{existing}`");
                     }
                 }
             }
         }
     }
-
-    ClvmDeriveArgs {
-        repr: repr.expect(
-            "expected clvm attribute parameter of either `tuple`, `proper_list`, or `curried_args`",
-        ),
-    }
+    repr
 }
 
 pub fn add_trait_bounds(generics: &mut Generics, bound: TypeParamBound) {

clvm-derive/src/to_clvm.rs

@@ -42,9 +42,9 @@ pub fn to_clvm(mut ast: DeriveInput) -> TokenStream {
 
     // `list_macro` encodes a nested tuple containing each of the struct field values within.
     let list_macro = match args.repr {
-        Repr::ProperList => quote!( #crate_name::clvm_list ),
+        Repr::List => quote!( #crate_name::clvm_list ),
         Repr::Tuple => quote!( #crate_name::clvm_tuple ),
-        Repr::CurriedArgs => quote!( #crate_name::clvm_curried_args ),
+        Repr::Curry => quote!( #crate_name::clvm_curried_args ),
     };
 
     add_trait_bounds(&mut ast.generics, parse_quote!(#crate_name::ToClvm));

clvm-traits/src/lib.rs

@@ -8,8 +8,8 @@
 //! with one of the following encodings:
 //!
 //! * `#[clvm(tuple)]` for unterminated lists such as `(A . (B . C))`.
-//! * `#[clvm(proper_list)]` for proper lists such as `(A B C)`, or in other words `(A . (B . (C . ())))`.
-//! * `#[clvm(curried_args)]` for curried arguments such as `(c (q . A) (c (q . B) (c (q . C) 1)))`.
+//! * `#[clvm(list)]` for proper lists such as `(A B C)`, or in other words `(A . (B . (C . ())))`.
+//! * `#[clvm(curry)]` for curried arguments such as `(c (q . A) (c (q . B) (c (q . C) 1)))`.
 
 #![cfg_attr(
     feature = "derive",
@@ -90,28 +90,28 @@ mod tests {
     }
 
     #[test]
-    fn test_proper_list() {
+    fn test_list() {
         #[derive(Debug, ToClvm, FromClvm, PartialEq, Eq)]
-        #[clvm(proper_list)]
-        struct ProperListStruct {
+        #[clvm(list)]
+        struct ListStruct {
             a: u64,
             b: i32,
         }
 
-        check(ProperListStruct { a: 52, b: -32 }, "ff34ff81e080");
+        check(ListStruct { a: 52, b: -32 }, "ff34ff81e080");
     }
 
     #[test]
-    fn test_curried_args() {
+    fn test_curry() {
         #[derive(Debug, ToClvm, FromClvm, PartialEq, Eq)]
-        #[clvm(curried_args)]
-        struct CurriedArgsStruct {
+        #[clvm(curry)]
+        struct CurryStruct {
             a: u64,
             b: i32,
         }
 
         check(
-            CurriedArgsStruct { a: 52, b: -32 },
+            CurryStruct { a: 52, b: -32 },
             "ff04ffff0134ffff04ffff0181e0ff018080",
         );
     }

src/fast_forward.rs

@@ -16,22 +16,22 @@ pub struct SingletonStruct {
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(curried_args)]
+#[clvm(curry)]
 pub struct SingletonArgs {
     pub singleton_struct: SingletonStruct,
     pub inner_puzzle: NodePtr,
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct LineageProof {
     pub parent_parent_coin_id: Bytes32,
     pub parent_inner_puzzle_hash: Bytes32,
     pub parent_amount: u64,
 }
 
 #[derive(FromClvm, ToClvm, Debug)]
-#[clvm(proper_list)]
+#[clvm(list)]
 pub struct SingletonSolution {
     pub lineage_proof: LineageProof,
     pub amount: u64,