idl: Support NonZero<num> in IDL

jamie-osec · jamie-osec · commit ee71a8d97155 · 2025-11-13T17:12:49.000Z
diff --git a/cli/src/lib.rs b/cli/src/lib.rs
@@ -2899,6 +2899,7 @@ fn deserialize_idl_type_to_json(
                 deserialize_idl_type_to_json(ty, data, parent_idl)?
             }
         }
+        IdlType::NonZero(ty) => deserialize_idl_type_to_json(ty, data, parent_idl)?,
         IdlType::Vec(ty) => {
             let size: usize = <u32 as AnchorDeserialize>::deserialize(data)?
                 .try_into()
diff --git a/idl/spec/src/lib.rs b/idl/spec/src/lib.rs
@@ -306,6 +306,7 @@ pub enum IdlType {
         #[serde(default, skip_serializing_if = "is_default")]
         generics: Vec<IdlGenericArg>,
     },
+    NonZero(Box<IdlType>),
     Generic(String),
 }
 
@@ -354,6 +355,20 @@ impl FromStr for IdlType {
                     )?;
                     return Ok(IdlType::Vec(Box::new(inner_ty)));
                 }
+                // NonZero<u8>
+                if let Some(inner) = s.strip_prefix("NonZero<") {
+                    let inner_ty = Self::from_str(
+                        inner
+                            .strip_suffix('>')
+                            .ok_or_else(|| anyhow!("Invalid NonZero"))?,
+                    )?;
+                    return Ok(IdlType::NonZero(Box::new(inner_ty)));
+                }
+                // NonZeroU8
+                if let Some(inner) = s.strip_prefix("NonZero") {
+                    let inner_ty = Self::from_str(&inner.to_lowercase())?;
+                    return Ok(IdlType::NonZero(Box::new(inner_ty)));
+                }
 
                 if s.starts_with('[') {
                     fn array_from_str(inner: &str) -> IdlType {
@@ -499,4 +514,16 @@ mod tests {
             }
         )
     }
+
+    #[test]
+    fn nonzero() {
+        assert_eq!(
+            IdlType::from_str("NonZero<u64>").unwrap(),
+            IdlType::NonZero(Box::new(IdlType::U64)),
+        );
+        assert_eq!(
+            IdlType::from_str("NonZeroU8").unwrap(),
+            IdlType::NonZero(Box::new(IdlType::U8)),
+        );
+    }
 }
diff --git a/idl/src/convert.rs b/idl/src/convert.rs
@@ -244,6 +244,7 @@ mod legacy {
         Array(Box<IdlType>, usize),
         GenericLenArray(Box<IdlType>, String),
         Generic(String),
+        NonZero(Box<IdlType>),
         DefinedWithTypeArgs {
             name: String,
             args: Vec<IdlDefinedTypeArg>,
@@ -491,6 +492,7 @@ mod legacy {
                 IdlType::GenericLenArray(ty, generic) => {
                     t::IdlType::Array(ty.into(), t::IdlArrayLen::Generic(generic))
                 }
+                IdlType::NonZero(ty) => t::IdlType::NonZero(ty.into()),
                 _ => serde_json::to_value(value)
                     .and_then(serde_json::from_value)
                     .unwrap(),
diff --git a/lang/attribute/program/src/declare_program/common.rs b/lang/attribute/program/src/declare_program/common.rs
@@ -89,6 +89,7 @@ pub fn convert_idl_type_to_str(ty: &IdlType) -> String {
             .map(|generics| format!("{name}<{generics}>"))
             .unwrap_or(name.into()),
         IdlType::Generic(ty) => ty.into(),
+        IdlType::NonZero(ty) => format!("NonZero<{}>", convert_idl_type_to_str(ty)),
         _ => unimplemented!("{ty:?}"),
     }
 }
@@ -309,6 +310,7 @@ fn can_derive_copy_ty(ty: &IdlType, ty_defs: &[IdlTypeDef]) -> bool {
             .map(|ty_def| can_derive_copy(ty_def, ty_defs))
             .expect("Type def must exist"),
         IdlType::Bytes | IdlType::String | IdlType::Vec(_) | IdlType::Generic(_) => false,
+        IdlType::NonZero(inner) => can_derive_copy_ty(inner, ty_defs),
         _ => true,
     }
 }
@@ -333,6 +335,7 @@ fn can_derive_default_ty(ty: &IdlType, ty_defs: &[IdlTypeDef]) -> bool {
             .map(|ty_def| can_derive_default(ty_def, ty_defs))
             .expect("Type def must exist"),
         IdlType::Generic(_) => false,
+        IdlType::NonZero(_) => false,
         _ => true,
     }
 }
diff --git a/lang/syn/src/idl/defined.rs b/lang/syn/src/idl/defined.rs
@@ -380,6 +380,7 @@ pub fn gen_idl_type(
         syn::Type::Path(path) if the_only_segment_is(path, "bool") => {
             Ok((quote! { #idl::IdlType::Bool }, vec![]))
         }
+        // Integer types
         syn::Type::Path(path) if the_only_segment_is(path, "u8") => {
             Ok((quote! { #idl::IdlType::U8 }, vec![]))
         }
@@ -416,6 +417,56 @@ pub fn gen_idl_type(
         syn::Type::Path(path) if the_only_segment_is(path, "i128") => {
             Ok((quote! { #idl::IdlType::I128 }, vec![]))
         }
+        // Non-zero integer types
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroU8") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::U8)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroI8") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::I8)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroU16") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::U16)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroI16") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::I16)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroU32") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::U32)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroI32") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::I32)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroU64") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::U64)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroI64") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::I64)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroU128") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::U128)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZeroI128") => Ok((
+            quote! { #idl::IdlType::NonZero(Box::new(#idl::IdlType::I128)) },
+            vec![],
+        )),
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZero") => {
+            let segment = get_first_segment(path);
+            let arg = get_angle_bracketed_type_args(segment)
+                .into_iter()
+                .next()
+                .unwrap();
+            let (inner, defined) = gen_idl_type(arg, generic_params)?;
+            Ok((quote! { #idl::IdlType::NonZero(Box::new(#inner)) }, defined))
+        }
         syn::Type::Path(path)
             if the_only_segment_is(path, "String") || the_only_segment_is(path, "str") =>
         {
diff --git a/tests/idl/idls/new.json b/tests/idl/idls/new.json
@@ -299,6 +299,18 @@
               "name": "FooEnum"
             }
           }
+        },
+        {
+          "name": "non_zero_u8",
+          "type": {
+            "nonzero": "u8"
+          }
+        },
+        {
+          "name": "non_zero_u64",
+          "type": {
+            "nonzero": "u64"
+          }
         }
       ]
     },
@@ -811,6 +823,18 @@
                 "name": "FooEnum"
               }
             }
+          },
+          {
+            "name": "non_zero_u8",
+            "type": {
+              "nonzero": "u8"
+            }
+          },
+          {
+            "name": "non_zero_u64",
+            "type": {
+              "nonzero": "u64"
+            }
           }
         ]
       }
@@ -898,4 +922,4 @@
       "value": "6"
     }
   ]
-}
+}
diff --git a/tests/idl/programs/idl/src/lib.rs b/tests/idl/programs/idl/src/lib.rs
@@ -1,5 +1,6 @@
 use anchor_lang::prelude::*;
 use anchor_spl::{token, token_interface};
+use std::num::{NonZero, NonZeroU64};
 
 declare_id!("id11111111111111111111111111111111111111111");
 
@@ -56,6 +57,8 @@ pub mod idl {
         enum_field_2: FooEnum,
         enum_field_3: FooEnum,
         enum_field_4: FooEnum,
+        non_zero_u8: NonZero<u8>,
+        non_zero_u64: NonZeroU64,
     ) -> Result<()> {
         ctx.accounts.state.set_inner(State {
             bool_field,
@@ -84,6 +87,8 @@ pub mod idl {
             enum_field_2,
             enum_field_3,
             enum_field_4,
+            non_zero_u8,
+            non_zero_u64,
         });
 
         Ok(())
@@ -200,6 +205,8 @@ pub struct State {
     enum_field_2: FooEnum,
     enum_field_3: FooEnum,
     enum_field_4: FooEnum,
+    non_zero_u8: NonZero<u8>,
+    non_zero_u64: NonZeroU64,
 }
 
 impl Default for State {
@@ -235,6 +242,8 @@ impl Default for State {
             },
             enum_field_3: FooEnum::Struct(BarStruct::default()),
             enum_field_4: FooEnum::NoFields,
+            non_zero_u8: NonZero::new(1).unwrap(),
+            non_zero_u64: NonZeroU64::new(1).unwrap(),
         }
     }
 }
diff --git a/ts/packages/anchor/src/coder/borsh/idl.ts b/ts/packages/anchor/src/coder/borsh/idl.ts
@@ -76,6 +76,16 @@ export class IdlCoder {
         return borsh.publicKey(fieldName);
       }
       default: {
+        if ("nonzero" in field.type) {
+          return borsh.nonzero(
+            IdlCoder.fieldLayout(
+              { type: field.type.nonzero },
+              types,
+              genericArgs,
+            ),
+            fieldName
+          );
+        }
         if ("option" in field.type) {
           return borsh.option(
             IdlCoder.fieldLayout(
diff --git a/ts/packages/anchor/src/idl.ts b/ts/packages/anchor/src/idl.ts
@@ -231,6 +231,7 @@ export type IdlType =
   | "pubkey"
   | IdlTypeOption
   | IdlTypeCOption
+  | IdlTypeNonZero
   | IdlTypeVec
   | IdlTypeArray
   | IdlTypeDefined
@@ -244,6 +245,10 @@ export type IdlTypeCOption = {
   coption: IdlType;
 };
 
+export type IdlTypeNonZero = {
+  nonzero: IdlType;
+};
+
 export type IdlTypeVec = {
   vec: IdlType;
 };
diff --git a/ts/packages/borsh/src/index.ts b/ts/packages/borsh/src/index.ts
@@ -175,6 +175,24 @@ export function option<T>(
   return new OptionLayout<T>(layout, property);
 }
 
+function decodeNonZero<T>(value: T): T {
+  if (value === 0) {
+    throw new Error("Invalid nonzero: " + value);
+  }
+  return value;
+}
+
+function encodeNonZero<T>(value: T): T {
+  return value;
+}
+
+export function nonzero<T>(
+  layout: Layout<T>,
+  property?: string
+): Layout<T> {
+  return new WrappedLayout(layout, decodeNonZero, encodeNonZero, property);
+}
+
 export function bool(property?: string): Layout<boolean> {
   return new WrappedLayout(u8(), decodeBool, encodeBool, property);
 }

Original file line number	Diff line number	Diff line change
`@@ -2899,6 +2899,7 @@ fn deserialize_idl_type_to_json(`
`2899`	`2899`	`deserialize_idl_type_to_json(ty, data, parent_idl)?`
`2900`	`2900`	`}`
`2901`	`2901`	`}`
	`2902`	`+ IdlType::NonZero(ty) => deserialize_idl_type_to_json(ty, data, parent_idl)?,`
`2902`	`2903`	`IdlType::Vec(ty) => {`
`2903`	`2904`	`let size: usize = <u32 as AnchorDeserialize>::deserialize(data)?`
`2904`	`2905`	`.try_into()`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ pub fn convert_idl_type_to_str(ty: &IdlType) -> String {`
`89`	`89`	`.map(\|generics\| format!("{name}<{generics}>"))`
`90`	`90`	`.unwrap_or(name.into()),`
`91`	`91`	`IdlType::Generic(ty) => ty.into(),`
	`92`	`+ IdlType::NonZero(ty) => format!("NonZero<{}>", convert_idl_type_to_str(ty)),`
`92`	`93`	`_ => unimplemented!("{ty:?}"),`
`93`	`94`	`}`
`94`	`95`	`}`
`@@ -309,6 +310,7 @@ fn can_derive_copy_ty(ty: &IdlType, ty_defs: &[IdlTypeDef]) -> bool {`
`309`	`310`	`.map(\|ty_def\| can_derive_copy(ty_def, ty_defs))`
`310`	`311`	`.expect("Type def must exist"),`
`311`	`312`	`IdlType::Bytes \| IdlType::String \| IdlType::Vec(_) \| IdlType::Generic(_) => false,`
	`313`	`+ IdlType::NonZero(inner) => can_derive_copy_ty(inner, ty_defs),`
`312`	`314`	`_ => true,`
`313`	`315`	`}`
`314`	`316`	`}`
`@@ -333,6 +335,7 @@ fn can_derive_default_ty(ty: &IdlType, ty_defs: &[IdlTypeDef]) -> bool {`
`333`	`335`	`.map(\|ty_def\| can_derive_default(ty_def, ty_defs))`
`334`	`336`	`.expect("Type def must exist"),`
`335`	`337`	`IdlType::Generic(_) => false,`
	`338`	`+ IdlType::NonZero(_) => false,`
`336`	`339`	`_ => true,`
`337`	`340`	`}`
`338`	`341`	`}`
Original file line number	Diff line number	Diff line change
`@@ -299,6 +299,18 @@`
`299`	`299`	`"name": "FooEnum"`
`300`	`300`	`}`
`301`	`301`	`}`
	`302`	`+ },`
	`303`	`+ {`
	`304`	`+ "name": "non_zero_u8",`
	`305`	`+ "type": {`
	`306`	`+ "nonzero": "u8"`
	`307`	`+ }`
	`308`	`+ },`
	`309`	`+ {`
	`310`	`+ "name": "non_zero_u64",`
	`311`	`+ "type": {`
	`312`	`+ "nonzero": "u64"`
	`313`	`+ }`
`302`	`314`	`}`
`303`	`315`	`]`
`304`	`316`	`},`
`@@ -811,6 +823,18 @@`
`811`	`823`	`"name": "FooEnum"`
`812`	`824`	`}`
`813`	`825`	`}`
	`826`	`+ },`
	`827`	`+ {`
	`828`	`+ "name": "non_zero_u8",`
	`829`	`+ "type": {`
	`830`	`+ "nonzero": "u8"`
	`831`	`+ }`
	`832`	`+ },`
	`833`	`+ {`
	`834`	`+ "name": "non_zero_u64",`
	`835`	`+ "type": {`
	`836`	`+ "nonzero": "u64"`
	`837`	`+ }`
`814`	`838`	`}`
`815`	`839`	`]`
`816`	`840`	`}`
`@@ -898,4 +922,4 @@`
`898`	`922`	`"value": "6"`
`899`	`923`	`}`
`900`	`924`	`]`
`901`		`-}`
	`925`	`+}`