Feature(evm-loader): derive BorshSchema, silence dead code warnings

[gBaGu]

Add possibility to generate Borsh schema for Typescript. See velas evm generate-borsh-schema for generation

Ts code generated from current instructions:

import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";
import Enum from "./extensions/enum";
import Struct from "./extensions/struct";
import { borshPublicKey } from "./extensions/publicKey";

borshPublicKey();

export class Transaction extends Struct {
    nonce: U256;
    gasPrice: Gas;
    gasLimit: Gas;
    action: TransactionAction;
    value: U256;
    signature: TransactionSignature;
    input: number[];
};

export class UnsignedTransaction extends Struct {
    nonce: U256;
    gasPrice: U256;
    gasLimit: U256;
    action: TransactionAction;
    value: U256;
    input: number[];
};

export class TransactionAction extends Enum {
    transactionActionCall: TransactionActionCall;
    transactionActionCreate: TransactionActionCreate;
};

export class TransactionActionCall extends Struct {
    unnamed_0: Address;
};

export class TransactionActionCreate extends Struct {
};

export class TransactionSignature extends Struct {
    v: BN;
    r: H256;
    s: H256;
};

export class FeePayerType extends Enum {
    feePayerTypeEvm: FeePayerTypeEvm;
    feePayerTypeNative: FeePayerTypeNative;
};

export class FeePayerTypeEvm extends Struct {
};

export class FeePayerTypeNative extends Struct {
};

export class EvmBigTransaction extends Enum {
    evmBigTransactionEvmTransactionAllocate: EvmBigTransactionEvmTransactionAllocate;
    evmBigTransactionEvmTransactionWrite: EvmBigTransactionEvmTransactionWrite;
};

export class EvmBigTransactionEvmTransactionAllocate extends Struct {
    size: BN;
};

export class EvmBigTransactionEvmTransactionWrite extends Struct {
    offset: BN;
    data: number[];
};

export class ExecuteTransaction extends Enum {
    executeTransactionSigned: ExecuteTransactionSigned;
    executeTransactionProgramAuthorized: ExecuteTransactionProgramAuthorized;
};

export class ExecuteTransactionSigned extends Struct {
    tx: Transaction | null;
};

export class ExecuteTransactionProgramAuthorized extends Struct {
    tx: UnsignedTransaction | null;
    from: evm::Address;
};

export class EvmInstruction extends Enum {
    evmInstructionSwapNativeToEther: EvmInstructionSwapNativeToEther;
    evmInstructionFreeOwnership: EvmInstructionFreeOwnership;
    evmInstructionEvmBigTransaction: EvmInstructionEvmBigTransaction;
    evmInstructionExecuteTransaction: EvmInstructionExecuteTransaction;
};

export class EvmInstructionSwapNativeToEther extends Struct {
    lamports: BN;
    evmAddress: evm::Address;
};

export class EvmInstructionFreeOwnership extends Struct {
};

export class EvmInstructionEvmBigTransaction extends Struct {
    unnamed_0: EvmBigTransaction;
};

export class EvmInstructionExecuteTransaction extends Struct {
    tx: ExecuteTransaction;
    feeType: FeePayerType;
};

export const SCHEMA = new Map<any, any>([
    [
            Transaction,
            {
                kind: 'struct', fields: [
            ['nonce', U256],
            ['gasPrice', Gas],
            ['gasLimit', Gas],
            ['action', TransactionAction],
            ['value', U256],
            ['signature', TransactionSignature],
            ['input', ['u8']],
                ],
            },
    ],
    [
            UnsignedTransaction,
            {
                kind: 'struct', fields: [
            ['nonce', U256],
            ['gasPrice', U256],
            ['gasLimit', U256],
            ['action', TransactionAction],
            ['value', U256],
            ['input', ['u8']],
                ],
            },
    ],
    [
            TransactionAction,
            {
                kind: 'enum', field: 'enum', values: [
            ['transactionActionCall', TransactionActionCall],
            ['transactionActionCreate', TransactionActionCreate],
                ],
            },
    ],
    [
            TransactionActionCall,
            {
                kind: 'struct', fields: [
            ['unnamed_0', Address],
                ],
            },
    ],
    [
            TransactionActionCreate,
            {
                kind: 'struct', fields: [
                ],
            },
    ],
    [
            TransactionSignature,
            {
                kind: 'struct', fields: [
            ['v', 'u64'],
            ['r', H256],
            ['s', H256],
                ],
            },
    ],
    [
            FeePayerType,
            {
                kind: 'enum', field: 'enum', values: [
            ['feePayerTypeEvm', FeePayerTypeEvm],
            ['feePayerTypeNative', FeePayerTypeNative],
                ],
            },
    ],
    [
            FeePayerTypeEvm,
            {
                kind: 'struct', fields: [
                ],
            },
    ],
    [
            FeePayerTypeNative,
            {
                kind: 'struct', fields: [
                ],
            },
    ],
    [
            EvmBigTransaction,
            {
                kind: 'enum', field: 'enum', values: [
            ['evmBigTransactionEvmTransactionAllocate', EvmBigTransactionEvmTransactionAllocate],
            ['evmBigTransactionEvmTransactionWrite', EvmBigTransactionEvmTransactionWrite],
                ],
            },
    ],
    [
            EvmBigTransactionEvmTransactionAllocate,
            {
                kind: 'struct', fields: [
            ['size', 'u64'],
                ],
            },
    ],
    [
            EvmBigTransactionEvmTransactionWrite,
            {
                kind: 'struct', fields: [
            ['offset', 'u64'],
            ['data', ['u8']],
                ],
            },
    ],
    [
            ExecuteTransaction,
            {
                kind: 'enum', field: 'enum', values: [
            ['executeTransactionSigned', ExecuteTransactionSigned],
            ['executeTransactionProgramAuthorized', ExecuteTransactionProgramAuthorized],
                ],
            },
    ],
    [
            ExecuteTransactionSigned,
            {
                kind: 'struct', fields: [
            ['tx', { kind: 'option', type: Transaction }],
                ],
            },
    ],
    [
            ExecuteTransactionProgramAuthorized,
            {
                kind: 'struct', fields: [
            ['tx', { kind: 'option', type: UnsignedTransaction }],
            ['from', evm::Address],
                ],
            },
    ],
    [
            EvmInstruction,
            {
                kind: 'enum', field: 'enum', values: [
            ['evmInstructionSwapNativeToEther', EvmInstructionSwapNativeToEther],
            ['evmInstructionFreeOwnership', EvmInstructionFreeOwnership],
            ['evmInstructionEvmBigTransaction', EvmInstructionEvmBigTransaction],
            ['evmInstructionExecuteTransaction', EvmInstructionExecuteTransaction],
                ],
            },
    ],
    [
            EvmInstructionSwapNativeToEther,
            {
                kind: 'struct', fields: [
            ['lamports', 'u64'],
            ['evmAddress', evm::Address],
                ],
            },
    ],
    [
            EvmInstructionFreeOwnership,
            {
                kind: 'struct', fields: [
                ],
            },
    ],
    [
            EvmInstructionEvmBigTransaction,
            {
                kind: 'struct', fields: [
            ['unnamed_0', EvmBigTransaction],
                ],
            },
    ],
    [
            EvmInstructionExecuteTransaction,
            {
                kind: 'struct', fields: [
            ['tx', ExecuteTransaction],
            ['feeType', FeePayerType],
                ],
            },
    ],
]);