Issue with Program and IDL

[Airbornharsh]

I have build the anchor and got the idl but when I am using it in Program then it is showing error

Error initializing: TypeError: Cannot use 'in' operator to search for 'vec' in pubkey
at IdlCoder.fieldLayout (index.js:1770:27)
at eval (index.js:1920:33)
at Array.map ()
at eval (index.js:1918:40)
at Array.map ()
at BorshInstructionCoder.parseIxLayout (index.js:1917:38)
at new BorshInstructionCoder (index.js:1863:47)
at new BorshCoder (index.js:2401:28)
at new Program (index.js:6485:68)

[acheroncrypto]

Make sure you use the same version for all Anchor tools. If it still doesn't work, please share a reproducable example as this error is not sufficient to debug the issue.

[ManOguaR]

Having same error. It appears to be at the last line from here (nw Program(...)):

const { Connection,PublicKey, SystemProgram, Transaction, sendAndConfirmTransaction } = require('@solana/web3.js');
const path = require('path');
const { Program, AnchorProvider } = require('@project-serum/anchor');

// Usa path.resolve para obtener la ruta absoluta al archivo IDL
const idl = require(path.resolve(__dirname, '../idl/dc_dao.json'));

// Cambiar la URL de la conexión para usar el nodo local
const localNetworkURL = "http://127.0.0.1:8899"; // URL del nodo local
const connection = new Connection(localNetworkURL, 'confirmed');

// Configurar el proveedor para usar el entorno local
const provider = new AnchorProvider(connection, AnchorProvider.local().wallet, AnchorProvider.defaultOptions());

// Obtener el ID del programa desde el IDL
const programID = new PublicKey(idl.address);
const program = new Program(idl, programID, provider);

It seems to be a problem with vec(Pubkey) definitions but i suspect that is not true...

can you put me in the rigth direction?

here's rust code:

use anchor_lang::prelude::*;

declare_id!("DCDaoJwgnPCQaDAr7ZBfLXupGPNx4KGDyaXsCqwv1rKQ");

#[program]
pub mod dc_dao {
    use super::*;

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        let dao_account = &mut ctx.accounts.dao_account;
        dao_account.is_initialized = true;
        dao_account.user_count = 0;
        dao_account.users = vec![];
        dao_account.banned_users = vec![];
        Ok(())
    }

    pub fn register_user(ctx: Context<RegisterUser>, user_pubkey: Pubkey) -> Result<()> {
        let dao_account = &mut ctx.accounts.dao_account;

        // Comprobar si el usuario está baneado antes de registrarlo
        require!(!dao_account.banned_users.contains(&user_pubkey), CustomError::UserBanned);

        dao_account.users.push(user_pubkey);
        dao_account.user_count += 1;

        let user_account = &mut ctx.accounts.user_account;
        user_account.user_pubkey = user_pubkey;
        user_account.inventory = Inventory {
            head: None,
            body: None,
            legs: None,
            feet: None,
            badge: None,
            access: None,
        };
        Ok(())
    }

    pub fn ban_user(ctx: Context<BanUser>, user_pubkey: Pubkey) -> Result<()> {
        let dao_account = &mut ctx.accounts.dao_account;
        dao_account.banned_users.push(user_pubkey);
        dao_account.users.retain(|&x| x != user_pubkey);
        dao_account.user_count = dao_account.users.len() as u64;
        Ok(())
    }

    pub fn update_user(ctx: Context<UpdateUser>, user_pubkey: Pubkey, new_inventory: Inventory) -> Result<()> {
        let user_account = &mut ctx.accounts.user_account;
        let dao_account = &ctx.accounts.dao_account;

        require!(user_account.user_pubkey == user_pubkey, CustomError::InvalidUser);
        require!(!dao_account.banned_users.contains(&user_pubkey), CustomError::UserBanned);

        user_account.inventory = new_inventory;
        Ok(())
    }

    pub fn delete_user(ctx: Context<DeleteUser>, user_pubkey: Pubkey) -> Result<()> {
        let dao_account = &mut ctx.accounts.dao_account;

        dao_account.users.retain(|&x| x != user_pubkey);
        dao_account.user_count = dao_account.users.len() as u64;

        let user_account = &mut ctx.accounts.user_account;
        **user_account.to_account_info().try_borrow_mut_lamports()? = 0;
        *user_account.to_account_info().try_borrow_mut_data()? = &mut [];
        Ok(())
    }

    pub fn get_all_users(ctx: Context<GetAllUsers>) -> Result<Vec<Pubkey>> {
        let dao_account = &ctx.accounts.dao_account;
        Ok(dao_account.users.clone())
    }

    pub fn get_user(ctx: Context<GetUser>, user_pubkey: Pubkey) -> Result<UserAccount> {
        let user_account = &ctx.accounts.user_account;
        require!(user_account.user_pubkey == user_pubkey, CustomError::InvalidUser);

        Ok(UserAccount {
            user_pubkey: user_account.user_pubkey,
            inventory: user_account.inventory.clone(),
        })
    }

    pub fn get_banned_users(ctx: Context<GetBannedUsers>) -> Result<Vec<Pubkey>> {
        let dao_account = &ctx.accounts.dao_account;
        Ok(dao_account.banned_users.clone())
    }

    pub fn get_user_is_banned(ctx: Context<GetUserIsBanned>, user_pubkey: Pubkey) -> Result<bool> {
        let dao_account = &ctx.accounts.dao_account;
         
        Ok(dao_account.banned_users.contains(&user_pubkey))
    }
    
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = user, space = DaoAccount::LEN)]
    pub dao_account: Account<'info, DaoAccount>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct RegisterUser<'info> {
    #[account(mut)]
    pub dao_account: Account<'info, DaoAccount>,
    #[account(init, payer = user, space = UserAccount::LEN)]
    pub user_account: Account<'info, UserAccount>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
    pub rent: Sysvar<'info, Rent>,
}

#[derive(Accounts)]
pub struct BanUser<'info> {
    #[account(mut)]
    pub dao_account: Account<'info, DaoAccount>,
    #[account(mut)]
    pub user: Signer<'info>,
}

#[derive(Accounts)]
pub struct UpdateUser<'info> {
    #[account(mut)]
    pub dao_account: Account<'info, DaoAccount>,
    #[account(mut)]
    pub user_account: Account<'info, UserAccount>,
    #[account(mut)]
    pub user: Signer<'info>,
}

#[derive(Accounts)]
pub struct DeleteUser<'info> {
    #[account(mut)]
    pub dao_account: Account<'info, DaoAccount>,
    #[account(mut)]
    pub user_account: Account<'info, UserAccount>,
    #[account(mut)]
    pub user: Signer<'info>,
}

#[derive(Accounts)]
pub struct GetAllUsers<'info> {
    pub dao_account: Account<'info, DaoAccount>,
}

#[derive(Accounts)]
pub struct GetUser<'info> {
    pub dao_account: Account<'info, DaoAccount>,
    pub user_account: Account<'info, UserAccount>,
}

#[derive(Accounts)]
pub struct GetBannedUsers<'info> {
    pub dao_account: Account<'info, DaoAccount>,
}

#[derive(Accounts)]
pub struct GetUserIsBanned<'info> {
    pub dao_account: Account<'info, DaoAccount>,
}

#[account]
pub struct DaoAccount {
    pub is_initialized: bool,
    pub user_count: u64,
    pub users: Vec<Pubkey>,
    pub banned_users: Vec<Pubkey>,
}

#[account]
pub struct UserAccount {
    pub user_pubkey: Pubkey,
    pub inventory: Inventory,
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct Inventory {
    pub head: Option<Pubkey>,
    pub body: Option<Pubkey>,
    pub legs: Option<Pubkey>,
    pub feet: Option<Pubkey>,
    pub badge: Option<Pubkey>,
    pub access: Option<Pubkey>,
}

impl DaoAccount {
    const LEN: usize = 8 + // Discriminator
        1 + // is_initialized
        8 + // user_count
        4 + 32 * 1000 + // 1000 Pubkeys inicialmente, puede ajustarse
        4 + 32 * 1000; // 1000 Pubkeys para usuarios baneados, puede ajustarse
}

impl UserAccount {
    const LEN: usize = 8 + // Discriminator
        32 + // user_pubkey
        6 * 33; // 6 slots de inventario con opción de Pubkey
}

#[error_code]
pub enum CustomError {
    #[msg("Invalid User")]
    InvalidUser,
    #[msg("User is banned")]
    UserBanned,
}

heres's IDL:

{
  "address": "DCDaoJwgnPCQaDAr7ZBfLXupGPNx4KGDyaXsCqwv1rKQ",
  "metadata": {
    "name": "dc_dao",
    "version": "0.1.0",
    "spec": "0.1.0"
  },
  "instructions": [
    {
      "name": "ban_user",
      "discriminator": [
        70,
        162,
        28,
        159,
        7,
        74,
        189,
        144
      ],
      "accounts": [
        {
          "name": "dao_account",
          "writable": true
        },
        {
          "name": "user",
          "writable": true,
          "signer": true
        }
      ],
      "args": [
        {
          "name": "user_pubkey",
          "type": "pubkey"
        }
      ]
    },
    {
      "name": "delete_user",
      "discriminator": [
        186,
        85,
        17,
        249,
        219,
        231,
        98,
        251
      ],
      "accounts": [
        {
          "name": "dao_account",
          "writable": true
        },
        {
          "name": "user_account",
          "writable": true
        },
        {
          "name": "user",
          "writable": true,
          "signer": true
        }
      ],
      "args": [
        {
          "name": "user_pubkey",
          "type": "pubkey"
        }
      ]
    },
    {
      "name": "get_all_users",
      "discriminator": [
        177,
        186,
        13,
        227,
        102,
        157,
        85,
        2
      ],
      "accounts": [
        {
          "name": "dao_account"
        }
      ],
      "args": [],
      "returns": {
        "vec": "pubkey"
      }
    },
    {
      "name": "get_banned_users",
      "discriminator": [
        63,
        250,
        22,
        59,
        235,
        127,
        78,
        194
      ],
      "accounts": [
        {
          "name": "dao_account"
        }
      ],
      "args": [],
      "returns": {
        "vec": "pubkey"
      }
    },
    {
      "name": "get_user",
      "discriminator": [
        243,
        117,
        71,
        238,
        196,
        232,
        11,
        158
      ],
      "accounts": [
        {
          "name": "dao_account"
        },
        {
          "name": "user_account"
        }
      ],
      "args": [
        {
          "name": "user_pubkey",
          "type": "pubkey"
        }
      ],
      "returns": {
        "defined": {
          "name": "UserAccount"
        }
      }
    },
    {
      "name": "get_user_is_banned",
      "discriminator": [
        49,
        183,
        38,
        110,
        64,
        9,
        44,
        208
      ],
      "accounts": [
        {
          "name": "dao_account"
        }
      ],
      "args": [
        {
          "name": "user_pubkey",
          "type": "pubkey"
        }
      ],
      "returns": "bool"
    },
    {
      "name": "initialize",
      "discriminator": [
        175,
        175,
        109,
        31,
        13,
        152,
        155,
        237
      ],
      "accounts": [
        {
          "name": "dao_account",
          "writable": true,
          "signer": true
        },
        {
          "name": "user",
          "writable": true,
          "signer": true
        },
        {
          "name": "system_program",
          "address": "11111111111111111111111111111111"
        }
      ],
      "args": []
    },
    {
      "name": "register_user",
      "discriminator": [
        2,
        241,
        150,
        223,
        99,
        214,
        116,
        97
      ],
      "accounts": [
        {
          "name": "dao_account",
          "writable": true
        },
        {
          "name": "user_account",
          "writable": true,
          "signer": true
        },
        {
          "name": "user",
          "writable": true,
          "signer": true
        },
        {
          "name": "system_program",
          "address": "11111111111111111111111111111111"
        },
        {
          "name": "rent",
          "address": "SysvarRent111111111111111111111111111111111"
        }
      ],
      "args": [
        {
          "name": "user_pubkey",
          "type": "pubkey"
        }
      ]
    },
    {
      "name": "update_user",
      "discriminator": [
        9,
        2,
        160,
        169,
        118,
        12,
        207,
        84
      ],
      "accounts": [
        {
          "name": "dao_account",
          "writable": true
        },
        {
          "name": "user_account",
          "writable": true
        },
        {
          "name": "user",
          "writable": true,
          "signer": true
        }
      ],
      "args": [
        {
          "name": "user_pubkey",
          "type": "pubkey"
        },
        {
          "name": "new_inventory",
          "type": {
            "defined": {
              "name": "Inventory"
            }
          }
        }
      ]
    }
  ],
  "accounts": [
    {
      "name": "DaoAccount",
      "discriminator": [
        174,
        58,
        100,
        153,
        105,
        117,
        66,
        171
      ]
    },
    {
      "name": "UserAccount",
      "discriminator": [
        211,
        33,
        136,
        16,
        186,
        110,
        242,
        127
      ]
    }
  ],
  "errors": [
    {
      "code": 6000,
      "name": "InvalidUser",
      "msg": "Invalid User"
    },
    {
      "code": 6001,
      "name": "UserBanned",
      "msg": "User is banned"
    }
  ],
  "types": [
    {
      "name": "DaoAccount",
      "type": {
        "kind": "struct",
        "fields": [
          {
            "name": "is_initialized",
            "type": "bool"
          },
          {
            "name": "user_count",
            "type": "u64"
          },
          {
            "name": "users",
            "type": {
              "vec": "pubkey"
            }
          },
          {
            "name": "banned_users",
            "type": {
              "vec": "pubkey"
            }
          }
        ]
      }
    },
    {
      "name": "Inventory",
      "type": {
        "kind": "struct",
        "fields": [
          {
            "name": "head",
            "type": {
              "option": "pubkey"
            }
          },
          {
            "name": "body",
            "type": {
              "option": "pubkey"
            }
          },
          {
            "name": "legs",
            "type": {
              "option": "pubkey"
            }
          },
          {
            "name": "feet",
            "type": {
              "option": "pubkey"
            }
          },
          {
            "name": "badge",
            "type": {
              "option": "pubkey"
            }
          },
          {
            "name": "access",
            "type": {
              "option": "pubkey"
            }
          }
        ]
      }
    },
    {
      "name": "UserAccount",
      "type": {
        "kind": "struct",
        "fields": [
          {
            "name": "user_pubkey",
            "type": "pubkey"
          },
          {
            "name": "inventory",
            "type": {
              "defined": {
                "name": "Inventory"
              }
            }
          }
        ]
      }
    }
  ]
}