Add chainId to PublicIdentity

A cryptographic keypair should be bound to one specific chain to avoid replay attacks. Also it should be easy to convert a PublicIdentity to an address, which requires the knowledge of the chainId.

• Add chainId parameter to Wallet.createIdentity
• Add chainId to PublicIdentity
• Remove redundant chainId parameter from Wallet.createTransactionSignature
• Convert MultiChainSigner.keyToAddress into identityToAddress(identity: PublicIdentity): Address
• Convert TxReadCodec.keyToAddress into identityToAddress(identity: PublicIdentity): Address

[ethanfrey]

Example interface (please modify, give feedback based on client requirements above, or question those requirements):

(Here I intentionally omit the naming of local identities, we can add that once we find a good agreement how derivations work).

export type AccountId = string & As<"accountId">;
export interface ChainPath {
  readonly chainId: ChainId;
  readonly algo: "secp256k1" | "ed25519";
  /** Examples are the methods from HdPaths */
  readonly path: (n: int) => ReadonlyArray<Slip10RawIndex>;
};
export interface IdentityQuery {
  readonly chain?: ChainId;
  readonly account?: AccountId;
};
export interface PublicIdentity {
  readonly chain: ChainId;
  readonly account: AccountId;
  readonly address: Address;  // chain-specific address
  readonly pubkey: PublicKeyBundle; // Note: contains algorithm
  readonly path: ReadonlyArray<Slip10RawIndex>;
  // TODO: add label
};

export declare class MultiChainProfile {
    static loadFrom(db: LevelUp<AbstractLevelDOWN<string, string>>, password: string): Promise<MultiChainProfile>;

    readonly createdAt: ReadonlyDate;
    readonly locked: ValueAndUpdates<boolean>;
    readonly accounts: ValueAndUpdates<ReadonlyArray<AccountId>>;
    readonly chains: ValueAndUpdates<ReadonlyArray<ChainPath>>;

    constructor(options?: MultiChainOptions);
    storeIn(db: LevelUp<AbstractLevelDOWN<string, string>>, password: string): Promise<void>;
    lock(): void;

    /** This creates a new account and initializes a PublicIdentity for each Chain */
    createAccount(): Promise<AccountId>;
    /** This adds support for a chain, and adds a new PublicIdentity for each existing Account */
    addChain(chain: ChainPath): Promise<void>; 

    getIdentities(query: IdentityQuery): ReadonlyArray<PublicIdentity>;
    // TODO: watchIdentities as well???
    // watchIdentities(query: IdentityQuery): Stream<ReadonlyArray<PublicIdentity>>;

    // here we just use AccountId, as ChainId is inside the UnsignedTransaction, and the profile can use that info to find the proper PublicIdentity
    signTransaction(identity: AccountId, transaction: UnsignedTransaction, codec: TxCodec, nonce: Nonce): Promise<SignedTransaction>;
    appendSignature(identity: AccountId, originalTransaction: SignedTransaction, codec: TxCodec, nonce: Nonce): Promise<SignedTransaction>;

    // TODO: maybe rename... we can guaranteed it is mnemonic in this case.
    printableSecret(): string;
}

(note: updated types for signing a bit)

[ethanfrey]

After some discussion with Simon, I support this issue:

• All my comments for functionality should go into some IdentityManager that can be implemented in the Wallet application to provide whatever functionality we need.
• Add chainId to all Identities in UserProfile, which can then easily get a unique address from the signer, as Simon suggested above.
• Update interface on MultiChainSigner, so one could drop in IdentityManager as an alternative to UserProfile (will make PR now).