HIP-338: Signature and Wallet Providers

/**
 * The following two classes are examples of what `MyHbarWallet` can create to allow users
 * to easily use them as Hedera wallets, signers, and providers.
 */

/**
 * MyHbarWallet can inject this class into the DOM at global scope
 */
class MyHbarWalletWallet extends Wallet {
    private accountId: AccountId;
    private provider: MyHbarWalletProvider;

    private constructor(privateKey: PrivateKey, accountId: AccountId | null, ledgerId: LedgerId) {
        super();

        /**
         * Use secure storage for the public key and transaction signer
         * No access to the private key
         */
        window.sessionStorage.setItem("publicKey", privateKey.publicKey);
        window.sessionStorage.setItem("transactionSigner", privateKey.sign);

        this.accountId = accountId != null
            ? accountId
            : privateKey.publicKey.toAccountId(0, 0);

        this.provider = MyHbarWalletProvider.forLedgerId(ledgerId);
    }

    /**
     * Perhaps MyHbarWallet could add a method on this globally accessible class
     * to easily get the currently logged in user's wallet or initiate the logging
     * in process.
     */
    static getCurrent(): MyHbarWalletWallet {
        // ...
    }

    getProvider(): Provider {
        return this.provider;
    }

    getAccountKey(): Key {
        return window.sessionStorage.getItem("publicKey");
    }

    static async createRandomED25519(): Promise<MyHbarWalletWallet> {
        return MyHbarWalletWallet(await PrivateKey.generateED25519Async());
    }

    static async createRandomECDSA(): Promise<MyHbarWalletWallet> {
        return MyHbarWalletWallet(await PrivateKey.generateECDSA());
    }

    async sign(messages: Uint8Array[]): Promise<SignerSignature[][]> {
        return Promise.resolve(messages.map((message) => {
            return [window.sessionStorage.getItem("transactionSigner")(message)];
        }));
    }

    async signTransaction(transaction: Transaction): Promise<Transaction> {
        const publicKey = window.sessionStorage.getItem("publicKey");
        const transactionSigner = window.sessionStorage.getItem("transactionSigner");
        await transaction.signWith(publicKey, transactionSigner);
        return transaction;
    }
    
    sendRequest<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>): Promise<OutputT> {
        return this.provider.sendRequest(request);
    }

    async checkTransaction(transaction: Transaction): Promise<Transaction> {
        return Promise.resovle(() => {
            const transactionId = transaction.transactionId;

            if (transactionId != null && transactionId.accountId.toString() != this.accountId.toString()) {
                throw new Error("TransactionID already set to a different account");
            }

            const nodeAccountIds = transaction.nodeAccountIds
                .map((nodeAccountId) => nodeAccountId.toString());
            const network = Object.values(this.provider.client.network)
                .map((nodeAccountId) => nodeAccountId.toString());

            if (!nodeAccountIds.reduce((previous, current) => previous && network.includes(current), true)) {
                throw new Error("Transaction already set node account IDs to values not within the current network");
            }

            return transaction;
        });
    }

    async populateTransaction(transaction: Transaction): Promise<Transaction> {
        await this.checkTransaction(transaction);

        transaction.setTransactionId(Transaction.generate(this.accountId));
        transaction.setNodeAccountIds(Object.values(this.provider.client.network));

        return transaction;
    }

    getLedgerId(): LedgerId {
        return this.provider.getLedgerId();
    }

    getAccountId(): AccountId {
        return this.accountId;
    }

    getAccountBalance(): Promise<AccountBalance> {
        return this.provider.getAccountBalance(this.accountId);
    }

    getAccountInfo(): Promise<AccountInfo> {
        return this.provider.getAccountInfo(this.accountId);
    }

    getAccountRecords(): Promise<TransactionRecord[]> {
        return this.provider.getAccountRecords(this.accountId);
    }
}

/**
 * MyHbarWallet can inject this class into the DOM at global scope
 */
class MyHbarWalletProvider extends Provider {
    private client: Client;

    private constructor(ledgerId: LedgerId) {
        super();

        this.client = Client.forName(ledgerId.toString());
    }

    static forLedgerId(ledgerId: LedgerId): MyHbarWalletProvider {
        return new MyHbarWalletProvider(ledgerId);
    }

    getLedgerId(): LedgerId {
        return client.getLedgerId();
    }

    getNetwork(): Promise<{ [key: string]: AccountId }> {
        return Promise.resolve(client.network);
    }

    getMirrorNetwork(): Promise<string[]> {
        return Promise.resolve(client.mirrorNetwork);
    }

    getAccountBalance(accountId: AccountId): Promise<AccountBalance> {
        return new AccountBalanceQuery()
            .setAccountId(accountId)
            .execute(this.client);
    }

    getAccountInfo(accountId: AccountId): Promise<AccountInfo> {
        return new AccountInfoQuery()
            .setAccountId(accountId)
            .execute(this.client);
    }

    getAccountRecords(accountId: AccountId): Promise<TransactionRecord[]> {
        return new AccountRecordsQuery()
            .setAccountId(accountId)
            .execute(this.client);
    }

    sendRequest<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>): Promise<OutputT> {
        return transaction.execute(this.client);
    }

    waitForReceipt(response: TransactionResponse): Promise<TransactionReceipt> {
        return response.getReceipt(this.client);
    }
}

/**
 * The following is an example of how someone can use the `MyHbarWalletWallet` from within
 * the browser class while on https://myhbarwallet.com
 */

const wallet = MyHbarWalletWallet.getCurrent();

async function main() {
    const balance = await wallet.getAccountBalance();
    console.log(`Current Balance for account: ${wallet.accountId.toString()} is ${balance.toString()}`);
}

/**
 * The following two classes are examples of what `MyHbarWallet` can create to allow users
 * to easily use them as Hedera wallets, signers, and providers.
 * This could be put into a npm package.
 */

/**
 * This signer does not have access to the private key(s) for the account, instead
 * it uses the provider to communicate with MyHbarWallet extension which does the actual
 * signing and potentially sending of a transaction.
 */
class MyHbarWalletSigner extends Signer {
    private accountKey: Key;
    private accountId: AccountId;
    private provider: MyHbarWalletProvider;

    constructor(accountKey: Key, accountId: AccountId, ledgerId: LedgerId) {
        super();

        this.accountKey = accountKey;
        this.accountId = accountId;
        this.provider = new MyHbarWalletProvider(ledgerId);
    }

    static async login(accountId?: AccountId): Promise<MyHbarWalletSigner> {
        const response = await MyHbarWalletProvider.login(accountId);
        return new MyHbarWalletSigner(response.accountKey, response.accountId, response.ledgerId);
    }

    getProvider(): Provider {
        return this.provider;
    }

    getAccountKey(): Key {
        return this.accountKey;
    }

    static async createRandomED25519(): Promise<MyHbarWalletWallet> {
        const response = await this.provider.createRandomED25519();
        return new MyHbarWalletSigner(response.accountKey, response.accountId);
    }

    static async createRandomECDSA(): Promise<MyHbarWalletWallet> {
        const response = await this.provider.createRandomECDSA();
        return new MyHbarWalletSigner(response.accountKey, response.accountId);
    }

    sign(messages: Uint8Array[]): Promise<SignerSignature[][]> {
        return this.provider.sign(messages);
    }

    async signTransaction(transaction: Transaction): Promise<Transaction> {
        return this.provider.signTransaction(transaction);
    }
h
    sendRequest<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>): Promise<OutputT> {
        return this.provider.sendRequest(request);
    }

    checkTransaction(transaction: Transaction): Promise<void> {
        return this.provider.checkTransaction(transaction);
    }

    populateTransaction(transaction: Transaction): Promise<void> {
        return this.provider.propulateTransaction(transaction);
    }

    getLedgerId(): LedgerId {
        return this.provider.getLedgerId();
    }

    getAccountId(): AccountId {
        return this.accountId;
    }

    getAccountBalance(): Promise<AccountBalance> {
        return this.provider.getAccountBalance(this.accountId);
    }

    getAccountInfo(): Promise<AccountInfo> {
        return this.provider.getAccountInfo(this.accountId);
    }

    getAccountRecords(): Promise<TransactionRecord[]> {
        return this.provider.getAccountRecords(this.accountId);
    }
}

/**
 * This provider is not a communciation with a Hedera network directly, but instead
 * communicates with MyHbarWallet which finally communicates with an actual Hedera
 * network.
 *
 * Note: This provider does not use JSON RPC it just uses a mock REST API. However,
 * MyHbarWallet is free to use whatever protocol they'd like since the SDK does
 * not put a requirement on the communication protocol.
 */
class MyHbarWalletProvider extends Provider {
    /**
     * Just an example endpoint
     */
    private static API_ENDPOINT: string = `https://myhbarwallet.com/api/v1/`;

    private ledgerId: LedgerId;

    constructor(ledgerId: LedgerId) {
        super();

        this.ledgerId = ledgerId;
    }

    static async login(accountId?: AccountId): Promise<{ accountId: AccountId, accountKey: Key, ledgerId: LedgerId }> {
        /**
         * Attempt to log into MyHbarWallet or let MyHbarWallet initiate the login process.
         * This could for instance communicate with MyHbarWallet extension and let the user
         * confirm which account they'd like to login as before proceeding.
         */
        const body = JSON.stringify({accountId: accountId?.toString() });
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/login`, { method: "POST", body });
        return response.json();
    }

    static async createRandomED25519(): Promise<{ accountKey: Key, accountId: AccountId, ledgerId: LedgerId }> {
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/create_random_ed25519`);
        return response.json();
    }

    static async createRandomECDSA(): Promise<{ accountKey: Key, accountId: AccountId, ledgerId: LedgerId }> {
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/create_random_ecdsa`);
        return response.json();
    }

    getLedgerId(): LedgerId {
        return this.ledgerId;
    }

    async getNetwork(): Proimse<{ [key: string]: AccountId }> {
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/get_network`);
        return response.json()
    }

    async getMirrorNetwork(): Proimse<string[]> {
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/get_mirror_network`);
        return response.json().mirrorNetwork;
    }

    async sign(messages: UintArray[]): Promise<SignerSignature[][]> {
        const body = JSON.stringify({messages: messages.map((message) => hex.encode(transaction.toBytes()))});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/sign_message`, {method: "POST", body});
        return response.json().signerSignature.map((signatureSignure) => SignerSignature.fromJson(signatureSignature));
    }

    async signTransaction(transaction: Transaction): Promise<Transaction> {
        const body = JSON.stringify({transaction: hex.encode(transaction.toBytes())});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/sign_transaction`, {method: "POST", body});
        return Transaction.fromBytes(hex.decode(response.json().transaction));
    }

    async sendRequest<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>): Promise<OutputT> {
        const body = JSON.stringify({request: hex.encode(request.toBytes())});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/send_request`, {method: "POST", body});
        // Decode Response into correct type
        return decodedResponse;
    }

    async checkTransaction(transaction: Transaction): Promise<Transaction> {
        const body = JSON.stringify({transaction: hex.encode(transaction.toBytes())});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/check_transaction`, {method: "POST", body});
        return Transaction.fromBytes(hex.decode(response.json().transaction));
    }

    async populateTransaction(transaction: Transaction): Promise<Transaction> {
        const body = JSON.stringify({transaction: hex.encode(transaction.toBytes())});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/populate_transaction`, {
            method: "POST",
            body
        });
        return Transaction.fromBytes(hex.decode(response.json().transaction));
    }

    async getAccountBalance(accountId: AccountId): Promise<AccountBalance> {
        const body = JSON.stringify({accountId});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/get_account_balance`, {
            method: "POST",
            body
        });
        return AccountBalance.fromJson(response.json());
    }

    async getAccountInfo(accountId: AccountId): Promise<AccountInfo> {
        const body = JSON.stringify({accountId});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/get_account_info`, {method: "POST", body});
        return AccountInfo.fromJson(response.json());
    }

    async getAccountRecords(accountId: AccountId): Promise<TransactionRecord[]> {
        const body = JSON.stringify({accountId});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/get_account_records`, {
            method: "POST",
            body
        });
        return response.json().transactionRecords.map((record) => TransactionRecord.fromJson(record));
    }

    async waitForReceipt(transactionResponse: TransactionResponse): Promise<TransactionReceipt> {
        const body = JSON.stringify({transactionResponse});
        const response = await fetch(`${MyHbarWalletProvider.API_ENDPOINT}/wait_for_receipt`, {method: "POST", body});
        return TransactionReceipt.fromJson(response.json());
    }
}

/**
 * The following is an example of how a user can use MyHbarWallet's package to log into
 * their account and query they're balance
 */

async function main() {
    const signer = await MyHbarWalletSigner.login();

    const balance = await signer.getAccountBalance();
    console.log(`Current Balance for account: ${signer.getAccountId().toString()} is ${balance.toString()}`);

    // Query the account info using the signer directly
    let info = await signer.sendQuery(new AccountInfoQuery().setAccountId(signer.getAccountId()));
    console.log(`The account info for the current account is: ${info.toString()}`);
    
    // Query the account info using the SDK's `executeWithSigner()` method
    info = await new AccountInfoQuery()
        .setAccountId(signer.getAccountId())
        .executeWithSigner(signer);
    console.log(`The account info for the current account is: ${info.toString()}`);

    // You're also able to freeze and sign transactions using `*WithSigner()` metohds
    const frozenTransferTransaction = await new TransferTransaction()
        .addHbarTransfer("0.0.3", 1)
        .addHbarTransfer(signer.getAccountId(), -1)
        .freezeWithSigner(signer);
    
    const signedTransferTransaction = await frozenTransferTransaction.signWithSigner(signer);
        
}