feat: IDL support for custom vector length discriminators by Otter-0x4ka5h · Pull Request #4148 · otter-sec/anchor

Otter-0x4ka5h · 2025-12-22T14:57:18Z

Anchor IDLs now support vectors with custom length discriminators (u8, u16, or u32), not just the default u32. This helps optimize account size for programs that use compact vectors.

Fixes #4076

vercel · 2025-12-22T14:57:22Z

Someone is attempting to deploy a commit to the Solana Foundation Team on Vercel.

A member of the Team first needs to authorize it.

acheroncrypto

Have you seen #4076 (comment) ?

0x4ka5h · 2025-12-22T16:07:52Z

@acheroncrypto sorry for the confusion here, will make changes. I think I pushed the wrong commit. was implemented with

impl IdlSerialization {
    /// Returns the number of bytes used for Vec length prefix in this serialization format.
    pub fn vec_length_bytes(&self) -> usize {
        match self {
            IdlSerialization::Borsh => 4,
            IdlSerialization::BorshU8 => 1,
            IdlSerialization::BorshU16 => 2,
            IdlSerialization::Bytemuck | IdlSerialization::BytemuckUnsafe => {
                8
            }
            IdlSerialization::Custom(_) => {
                4
            }
        }
    }
}

0x4ka5h · 2025-12-22T16:17:20Z

Have you seen #4076 (comment) ?

re-pushed the correct changes

acheroncrypto

Overall, I think the approach is correct, but there are a few more things that need to get addressed:

The serialization should apply to all unsized types; otherwise, it would be very unintuitive (on-chain programs can't handle more than 2 bytes length borsh de/serialization anyway)
How to use the new serialization specs?
- In programs, how to use them without having to manually implement the de/serialization?
- How to include this information (the serialization field) in the IDL conveniently?
Perhaps something like a generic #[serialization] attribute or a specific #[custom_borsh] similar to the #[zero_copy] attribute?
declare_program! also needs to support these new serialization methods, e.g. in:

https://github.com/solana-foundation/anchor/blob/d7ace7a47d9720386d5ddc1690f358e2d1d33ff5/lang/attribute/program/src/declare_program/common.rs#L133-L138

Depending on the resolution of the last point, something like:
```
IdlSerialization::BorshU8 => quote!(#[custom_borsh(u8)]),
IdlSerialization::BorshU16 => quote!(#[custom_borsh(u16)]),
```

acheroncrypto · 2026-01-12T17:43:02Z

      - run: cd tests/bpf-upgradeable-state
      - run: cd tests/bpf-upgradeable-state && anchor build --skip-lint --ignore-keys
-      - run: cd tests/bpf-upgradeable-state && solana program deploy --program-id program_with_different_programdata.json target/deploy/bpf_upgradeable_state.so
+      - run: cd tests/bpf-upgradeable-state && solana program deploy --program-id program_with_different_programdata.json --use-rpc target/deploy/bpf_upgradeable_state.so


Need rebase since this is fixed in master (#4164)

acheroncrypto · 2026-01-12T17:44:50Z

-                .try_into()
-                .unwrap();
+            // Use serialization format from parent type definition, or default to Borsh (u32)
+            let serialization = serialization.unwrap_or(&IdlSerialization::Borsh);


It's better to use the actual default rather than manually specifying the default.

Suggested change

let serialization = serialization.unwrap_or(&IdlSerialization::Borsh);

let serialization = serialization.unwrap_or_default();

acheroncrypto · 2026-01-12T17:45:32Z

 [dependencies]
 anyhow = "1"
 serde = { version = "1", features = ["derive"] }
+serde_json = "1.0.146"


Why do we need this? The IDL spec itself doesn't care about JSON at all.

Suggested change

serde_json = "1.0.146"

acheroncrypto · 2026-01-12T17:50:34Z


+impl IdlSerialization {
+    /// Returns the number of bytes used for Vec length prefix in this serialization format.
+    pub fn vec_length_bytes(&self) -> usize {


It will be unintuitive and inconsistent if other unsized types still use 4 bytes when they specify BorshU8 or BorshU16 serialization. Therefore, it would be better if this was a generalized method like length_prefix_bytes.

The return type should be Option<usize> instead of usize because not all serialization specs support unsized types.

Suggested change

pub fn vec_length_bytes(&self) -> usize {

pub fn length_prefix_bytes(&self) -> Option<usize> {

acheroncrypto · 2026-01-12T17:51:21Z

+            IdlSerialization::Borsh => 4,
+            IdlSerialization::BorshU8 => 1,
+            IdlSerialization::BorshU16 => 2,


In line with the previous comment:

Suggested change

IdlSerialization::Borsh => 4,

IdlSerialization::BorshU8 => 1,

IdlSerialization::BorshU16 => 2,

IdlSerialization::Borsh => Some(4),

IdlSerialization::BorshU8 => Some(1),

IdlSerialization::BorshU16 => Some(2),

acheroncrypto · 2026-01-12T17:57:05Z

            { ...field, type: genericArg.type },
-            types
+            types,
+            undefined,


Nit: it's better to use null when you need to pass a value that you can't omit.

Suggested change

undefined,

null,

acheroncrypto · 2026-01-12T17:57:19Z

+        return IdlCoder.fieldLayout(
+          { type: typeDef.type.alias, name },
+          types,
+          undefined,


Same here:

Suggested change

undefined,

null,

acheroncrypto · 2026-01-12T17:57:57Z

+        const vecValue = type.vec;
+        const innerType =
+          typeof vecValue === "string" || !("type" in vecValue)
+            ? typeof vecValue === "string"
+              ? vecValue
+              : (vecValue as any)
+            : vecValue.type;


What does this change achieve? It looks wrong. Serialization should not affect generic argument resolution.

Suggested change

const vecValue = type.vec;

const innerType =

typeof vecValue === "string" || !("type" in vecValue)

? typeof vecValue === "string"

? vecValue

: (vecValue as any)

: vecValue.type;

acheroncrypto · 2026-01-12T17:58:15Z

+            : vecValue.type;
        const args = IdlCoder.resolveGenericArgs({
-          type: type.vec,
+          type: innerType,


In line with the previous comment:

Suggested change

type: innerType,

type: type.vec,

acheroncrypto · 2026-01-12T17:58:42Z

+      const innerType = idlType.vec;
+      return `Vec<${this.formatIdlType(innerType)}>`;


This change doesn't seem to be doing anything.

Suggested change

const innerType = idlType.vec;

return `Vec<${this.formatIdlType(innerType)}>`;

return `Vec<${this.formatIdlType(idlType.vec)}>`;

vercel · 2026-01-17T12:36:34Z

Deployment failed with the following error:

The provided GitHub repository does not contain the requested branch or commit reference. Please ensure the repository is not empty.

Co-authored-by: acheron <98934430+acheroncrypto@users.noreply.github.com>

acheroncrypto reviewed Dec 22, 2025

View reviewed changes

acheroncrypto added idl related to the IDL, either program or client side feature labels Dec 22, 2025

0x4ka5h requested review from acheroncrypto and jamie-osec January 6, 2026 06:38

acheroncrypto requested changes Jan 12, 2026

View reviewed changes

Otter-0x4ka5h force-pushed the anchor#4076 branch from 51767f8 to 7256289 Compare January 17, 2026 12:38

Otter-0x4ka5h requested a review from acheroncrypto January 17, 2026 12:44

Akash Thota and others added 10 commits January 20, 2026 12:54

feat: IDL support for custom vector length discriminators

b94df81

rm .yarn cache

00ea662

rm yarnrc.yml & fmt

b4026f4

revert/ wrong commit

d59a2b2

fix ci & fmt

4c40149

fix prettier

25ce541

fix review changes

85ec484

Apply suggestion from @acheroncrypto

dab4ab4

Co-authored-by: acheron <98934430+acheroncrypto@users.noreply.github.com>

mistype dependency

0d3d3af

lint:fix

1059a19

Otter-0x4ka5h force-pushed the anchor#4076 branch from 6b09543 to 1059a19 Compare January 20, 2026 07:24

	let serialization = serialization.unwrap_or(&IdlSerialization::Borsh);
	let serialization = serialization.unwrap_or_default();

	pub fn vec_length_bytes(&self) -> usize {
	pub fn length_prefix_bytes(&self) -> Option<usize> {

		const innerType = idlType.vec;
		return `Vec<${this.formatIdlType(innerType)}>`;

	const innerType = idlType.vec;
	return `Vec<${this.formatIdlType(innerType)}>`;
	return `Vec<${this.formatIdlType(idlType.vec)}>`;

Conversation

Otter-0x4ka5h commented Dec 22, 2025

Uh oh!

vercel Bot commented Dec 22, 2025

Uh oh!

acheroncrypto left a comment

Choose a reason for hiding this comment

Uh oh!

0x4ka5h commented Dec 22, 2025

Uh oh!

0x4ka5h commented Dec 22, 2025

Uh oh!

acheroncrypto left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

vercel Bot commented Jan 17, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants