Add type alias support

[acheroncrypto]

Problem

Type aliases are not supported.

Summary of Changes

• Add type alias support for the IDL, TS client, and the CLI
• Add tests for type aliases

Example

Program:

use anchor_lang::prelude::*;

declare_id!("TypeA1ias1111111111111111111111111111111111");

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

    pub fn type_alias(ctx: Context<TypeAlias>, u8_array: U8Array) -> Result<()> {
        ctx.accounts.account.u8_array = u8_array;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct TypeAlias<'info> {
    #[account(zero)]
    pub account: Account<'info, TypeAliasAccount>,
}

#[account]
pub struct TypeAliasAccount {
    pub u8_array: U8Array,
}

pub type U8Array = [u8; 8];

IDL:

{
  "version": "0.1.0",
  "name": "type_alias",
  "instructions": [
    {
      "name": "typeAlias",
      "accounts": [
        {
          "name": "account",
          "isMut": true,
          "isSigner": false
        }
      ],
      "args": [
        {
          "name": "u8Array",
          "type": {
            "defined": "U8Array"
          }
        }
      ]
    }
  ],
  "accounts": [
    {
      "name": "TypeAliasAccount",
      "type": {
        "kind": "struct",
        "fields": [
          {
            "name": "u8Array",
            "type": {
              "defined": "U8Array"
            }
          }
        ]
      }
    }
  ],
  "types": [
    {
      "name": "U8Array",
      "type": {
        "kind": "alias",
        "value": {
          "array": [
            "u8",
            8
          ]
        }
      }
    }
  ]
}

TypeScript:

import * as anchor from "@coral-xyz/anchor";
import { assert } from "chai";

import type { TypeAlias } from "../target/types/type_alias";

describe("Type alias", () => {
  anchor.setProvider(anchor.AnchorProvider.env());
  const program = anchor.workspace.typeAlias as anchor.Program<TypeAlias>;

  it("Can use type aliases", async () => {
    const kp = anchor.web3.Keypair.generate();

    const u8Array = [1, 2, 3, 4, 5, 6, 7, 8];
    await program.methods
      .typeAlias(u8Array)
      .accounts({ account: kp.publicKey })
      .signers([kp])
      .preInstructions([
        await program.account.typeAliasAccount.createInstruction(kp),
      ])
      .rpc();

    const account = await program.account.typeAliasAccount.fetch(kp.publicKey);
    assert.deepEqual(account.u8Array, u8Array);
  });
});

Closes #1300, resolves #1632.

[vercel]

@acheroncrypto is attempting to deploy a commit to the coral-xyz Team on Vercel.

A member of the Team first needs to authorize it.

[buffalojoec]

This is awesome! I left a couple comments but implementation is solid.

Having this capability in Anchor is going to be super helpful.

[buffalojoec]

This wouldn't support type aliases with lifetimes right?

[acheroncrypto]

It supports the types that have FromStr implementation. It wouldn't support lifetimes because the IDL implementation itself doesn't support it.

[buffalojoec]

Nice 🤌🏼

[buffalojoec]

Looks like you dropped the catch-all else but didn't include a default case? ie:

default: {
   throw new Error(`Unknown type kind: ${typeDef}`);
}

The original is also spelled wrong lol (type kint)

[acheroncrypto]

Yes, I've dropped it because it should be unreachable, i.e. the value we are checking is generated from the IDL so it should never be outside of these specific cases.