The Technical Standard v1

https://github.com/cardinal-labs/cardinal-creator-standard

State

mint-manager

• [’mint-manager’, mint_id] - holds freeze/mint authority
  • version: u8
  • authority: Pubkey
  • ruleset: Pubkey
• [’ruleset’, name]
  • version: u8
  • authority Pubkey
  • check_seller_fee_balance_changes: boolean
  • disallowed_addresses: Vec<Pubkey>
  • allowed_programs: Vec<Pubkey>

Instructions

• initialize
  • check supply is 1
  • initialize mint_manager
  • set freeze authority to mint_manager
  • set mint authority to mint_manager
  • specify ruleset to use
• initialize_mint — maybe not needed because u can do this first and then call initialize
  • initialize token_manager
  • CPI to TokenKeg to mint with freeze-authority and mint_authority to token-manager
• initialize_account
  • CPI to associated_token to create ATA
  • freeze token account
• transfer
  • check instructions[0] in the transaction is program_id ctx.program_id and data discriminator is pre_transfer
  • check instructions[-1] in the transaction is program_id ctx.program_id and data discriminator is post_transfer
  • check target is not in the disallowed programs list
  • thaw
  • transfer
  • freeze
• approve (delegate)
  • check target is not in the disallowed programs list
  • thaw
  • approve
  • freeze
• revoke (delegate)
  • check target is not in the disallowed programs list
  • thaw
  • revoke
  • freeze
• close
  • thaw
  • close
• burn
  • thaw
  • burn
• add_disallowed_program
  • authority must sign
  • add address to disallowed programs
• remove_disallowed_program
  • authority must sign
  • remove address to disallowed programs
• pre_transfer - includes a random keypair to store pre-balance
  • initialize the balance_check account
    • Vec<BalanceCheck>
    • struct BalanceCheck
      • version? - u8 so we can distinguish different kinds of token accounts - maybe different arrays entirely?
      • address: PublicKey
      • mint: Pubkey::Default for sol
      • amount: u64
  • gather all accounts in all instructions and into a set() or map —> all_accounts_all_intstructions
  • gather all accounts from the pre instruction into a set —> pre_instruction_accounts
  • check that all accounts in all_accounts_all_intstructions set are in the pre_instruction_accounts set
  • iterate all accounts in pre_instruction_accounts and store a balance of SOL
    • if its owner is TokenKeg and it deserializes to a token account, store another entry for that token account balance
• post_transfer
  • we assume we already checked in the pre_transfer that all accounts are included and stored in balance_check PDA ——— we need a way to determine which balanced_check account this is
  • Create a map storing mint to balance change
  • Iterate all balance checks stored in the balance_check PDA, compute the difference in balance