@hashgraph/hedera-wallet-connect 2.0.4 → 2.0.5-canary.09073be.0

package/dist/lib/wallet/index.js

@@ -1,306 +0,0 @@
-/*
- *
- * Hedera Wallet Connect
- *
- * Copyright (C) 2023 Hedera Hashgraph, LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-import { Buffer } from 'buffer';
-import { Core } from '@walletconnect/core';
-import { WalletKit } from '@reown/walletkit';
-import { buildApprovedNamespaces, getSdkError } from '@walletconnect/utils';
-import { Wallet as HederaWallet, Client, AccountId } from '@hashgraph/sdk';
-import { HederaChainId, HederaSessionEvent, HederaJsonRpcMethod, base64StringToQuery, Uint8ArrayToBase64String, stringToSignerMessage, signatureMapToBase64String, signerSignaturesToSignatureMap, base64StringToTransaction, getHederaError, } from '../shared';
-import { proto } from '@hashgraph/proto';
-import Provider from './provider';
-export { default as WalletProvider } from './provider';
-/*
- *
- * @see {@link https://github.com/WalletConnect/walletconnect-monorepo/blob/v2.0/packages/web3wallet/src/client.ts}
- */
-export class HederaWeb3Wallet extends WalletKit {
-    /*
-     * Set default values for chains, methods, events
-     */
-    constructor(opts, chains = Object.values(HederaChainId), methods = Object.values(HederaJsonRpcMethod), sessionEvents = Object.values(HederaSessionEvent)) {
-        super(opts);
-        this.chains = chains;
-        this.methods = methods;
-        this.sessionEvents = sessionEvents;
-    }
-    // wrapper to reduce needing to instantiate Core object on client, also add hedera sensible defaults
-    static async create(projectId, metadata, chains, methods, sessionEvents) {
-        const wallet = new HederaWeb3Wallet({ core: new Core({ projectId }), metadata }, chains, methods, sessionEvents);
-        //https://github.com/WalletConnect/walletconnect-monorepo/blob/14f54684c3d89a5986a68f4dd700a79a958f1604/packages/web3wallet/src/client.ts#L178
-        wallet.logger.trace(`Initialized`);
-        try {
-            await wallet.engine.init();
-            wallet.logger.info(`Web3Wallet Initialization Success`);
-        }
-        catch (error) {
-            wallet.logger.info(`Web3Wallet Initialization Failure`);
-            wallet.logger.error(error.message);
-            throw error;
-        }
-        return wallet;
-    }
-    /*
-     * Hedera Wallet Signer
-     */
-    getHederaWallet(chainId, accountId, privateKey, _provider) {
-        const network = chainId.split(':')[1];
-        const client = Client.forName(network);
-        const provider = _provider !== null && _provider !== void 0 ? _provider : new Provider(client);
-        return new HederaWallet(accountId, privateKey, provider);
-    }
-    /*
-     * Session proposal
-     */
-    async buildAndApproveSession(accounts, { id, params }) {
-        // filter to get unique chains
-        const chains = accounts
-            .map((account) => account.split(':').slice(0, 2).join(':'))
-            .filter((x, i, a) => a.indexOf(x) == i);
-        return await this.approveSession({
-            id,
-            namespaces: buildApprovedNamespaces({
-                proposal: params,
-                supportedNamespaces: {
-                    hedera: {
-                        chains,
-                        methods: this.methods,
-                        events: this.sessionEvents,
-                        accounts,
-                    },
-                },
-            }),
-        });
-    }
-    /*
-     *  Session Requests
-     */
-    validateParam(name, value, expectedType) {
-        if (expectedType === 'array' && Array.isArray(value))
-            return;
-        if (typeof value === expectedType)
-            return;
-        throw getHederaError('INVALID_PARAMS', `Invalid paramameter value for ${name}, expected ${expectedType} but got ${typeof value}`);
-    }
-    parseSessionRequest(event, 
-    // optional arg to throw error if request is invalid, call with shouldThrow = false when calling from rejectSessionRequest as we only need id and top to send reject response
-    shouldThrow = true) {
-        const { id, topic } = event;
-        const { request: { method, params }, chainId, } = event.params;
-        let body;
-        // get account id from optional second param for transactions and queries or from transaction id
-        // this allows for the case where the requested signer is not the payer, but defaults to the payer if a second param is not provided
-        let signerAccountId;
-        // First test for valid params for each method
-        // then convert params to a body that the respective function expects
-        try {
-            switch (method) {
-                case HederaJsonRpcMethod.GetNodeAddresses: {
-                    // 1
-                    if (params)
-                        throw getHederaError('INVALID_PARAMS');
-                    break;
-                }
-                case HederaJsonRpcMethod.ExecuteTransaction: {
-                    // 2
-                    const { transactionList } = params;
-                    this.validateParam('transactionList', transactionList, 'string');
-                    body = base64StringToTransaction(transactionList);
-                    break;
-                }
-                case HederaJsonRpcMethod.SignMessage: {
-                    // 3
-                    const { signerAccountId: _accountId, message } = params;
-                    this.validateParam('signerAccountId', _accountId, 'string');
-                    this.validateParam('message', message, 'string');
-                    signerAccountId = AccountId.fromString(_accountId.replace(chainId + ':', ''));
-                    body = message;
-                    break;
-                }
-                case HederaJsonRpcMethod.SignAndExecuteQuery: {
-                    // 4
-                    const { signerAccountId: _accountId, query } = params;
-                    this.validateParam('signerAccountId', _accountId, 'string');
-                    this.validateParam('query', query, 'string');
-                    signerAccountId = AccountId.fromString(_accountId.replace(chainId + ':', ''));
-                    body = base64StringToQuery(query);
-                    break;
-                }
-                case HederaJsonRpcMethod.SignAndExecuteTransaction: {
-                    // 5
-                    const { signerAccountId: _accountId, transactionList } = params;
-                    this.validateParam('signerAccountId', _accountId, 'string');
-                    this.validateParam('transactionList', transactionList, 'string');
-                    signerAccountId = AccountId.fromString(_accountId.replace(chainId + ':', ''));
-                    body = base64StringToTransaction(transactionList);
-                    break;
-                }
-                case HederaJsonRpcMethod.SignTransaction: {
-                    // 6
-                    const { signerAccountId: _accountId, transactionBody } = params;
-                    this.validateParam('signerAccountId', _accountId, 'string');
-                    this.validateParam('transactionBody', transactionBody, 'string');
-                    signerAccountId = AccountId.fromString(_accountId.replace(chainId + ':', ''));
-                    body = Buffer.from(transactionBody, 'base64');
-                    break;
-                }
-                default:
-                    throw getSdkError('INVALID_METHOD');
-            }
-            // error parsing request params
-        }
-        catch (e) {
-            if (shouldThrow)
-                throw e;
-        }
-        return {
-            method: method,
-            chainId: chainId,
-            id,
-            topic,
-            body,
-            accountId: signerAccountId,
-        };
-    }
-    async executeSessionRequest(event, hederaWallet) {
-        const { method, id, topic, body } = this.parseSessionRequest(event);
-        return await this[method](id, topic, body, hederaWallet);
-    }
-    // https://docs.walletconnect.com/web3wallet/wallet-usage#responding-to-session-requests
-    async rejectSessionRequest(event, error) {
-        const { id, topic } = this.parseSessionRequest(event, false);
-        return await this.respondSessionRequest({
-            topic,
-            response: { id, error, jsonrpc: '2.0' },
-        });
-    }
-    /*
-     * JSON RPC Methods
-     */
-    // 1. hedera_getNodeAddresses
-    async hedera_getNodeAddresses(id, topic, _, // ignore this param to be consistent call signature with other functions
-    signer) {
-        const nodesAccountIds = signer.getNetwork();
-        const nodes = Object.values(nodesAccountIds).map((nodeAccountId) => nodeAccountId.toString());
-        const response = {
-            topic,
-            response: {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    nodes,
-                },
-            },
-        };
-        return await this.respondSessionRequest(response);
-    }
-    // 2. hedera_executeTransaction
-    async hedera_executeTransaction(id, topic, body, signer) {
-        const response = {
-            topic,
-            response: {
-                id,
-                result: (await signer.call(body)).toJSON(),
-                jsonrpc: '2.0',
-            },
-        };
-        return await this.respondSessionRequest(response);
-    }
-    // 3. hedera_signMessage
-    async hedera_signMessage(id, topic, body, signer) {
-        // signer takes an array of Uint8Arrays though spec allows for 1 message to be signed
-        const signerSignatures = await signer.sign(stringToSignerMessage(body));
-        const _signatureMap = proto.SignatureMap.create(signerSignaturesToSignatureMap(signerSignatures));
-        const signatureMap = signatureMapToBase64String(_signatureMap);
-        const response = {
-            topic,
-            response: {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    signatureMap,
-                },
-            },
-        };
-        return await this.respondSessionRequest(response);
-    }
-    // 4. hedera_signAndExecuteQuery
-    async hedera_signAndExecuteQuery(id, topic, body, signer) {
-        /*
-         * Can be used with return values the have a toBytes method implemented
-         * For example:
-         * https://github.com/hashgraph/hedera-sdk-js/blob/c4438cbaa38074d8bfc934dba84e3b430344ed89/src/account/AccountInfo.js#L402
-         */
-        const queryResult = await body.executeWithSigner(signer);
-        let queryResponse = '';
-        if (Array.isArray(queryResult)) {
-            queryResponse = queryResult.map((qr) => Uint8ArrayToBase64String(qr.toBytes())).join(',');
-        }
-        else {
-            queryResponse = Uint8ArrayToBase64String(queryResult.toBytes());
-        }
-        const response = {
-            topic,
-            response: {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    response: queryResponse,
-                },
-            },
-        };
-        return await this.respondSessionRequest(response);
-    }
-    // 5. hedera_signAndExecuteTransaction
-    async hedera_signAndExecuteTransaction(id, topic, body, signer) {
-        // check transaction is incomplete (HIP-745)
-        if (!body.isFrozen()) {
-            // set multiple nodeAccountIds and transactionId if not present
-            await body.freezeWithSigner(signer);
-        }
-        const signedTransaction = await signer.signTransaction(body);
-        const response = {
-            topic,
-            response: {
-                id,
-                result: (await signer.call(signedTransaction)).toJSON(),
-                jsonrpc: '2.0',
-            },
-        };
-        return await this.respondSessionRequest(response);
-    }
-    // 6. hedera_signTransaction
-    async hedera_signTransaction(id, topic, body, signer) {
-        const signerSignatures = await signer.sign([body]);
-        const _signatureMap = proto.SignatureMap.create(signerSignaturesToSignatureMap(signerSignatures));
-        const signatureMap = signatureMapToBase64String(_signatureMap);
-        const response = {
-            topic,
-            response: {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    signatureMap,
-                },
-            },
-        };
-        return await this.respondSessionRequest(response);
-    }
-}
-export default HederaWeb3Wallet;

package/dist/lib/wallet/provider.d.ts

@@ -1,17 +0,0 @@
-import { Client, type AccountId, type Executable, type Provider as HederaWalletProvider, type TransactionId, type TransactionResponse, type TransactionReceipt } from '@hashgraph/sdk';
-export default class Provider implements HederaWalletProvider {
-    private client;
-    constructor(client: Client);
-    static fromClient(client: Client): Provider;
-    getLedgerId(): import("@hashgraph/sdk").LedgerId | null;
-    getNetwork(): {
-        [key: string]: string | AccountId;
-    };
-    getMirrorNetwork(): string[];
-    getAccountBalance(accountId: AccountId | string): Promise<import("@hashgraph/sdk").AccountBalance>;
-    getAccountInfo(accountId: AccountId | string): Promise<import("@hashgraph/sdk").AccountInfo>;
-    getAccountRecords(accountId: string | AccountId): Promise<import("@hashgraph/sdk").TransactionRecord[]>;
-    getTransactionReceipt(transactionId: TransactionId | string): Promise<TransactionReceipt>;
-    waitForReceipt(response: TransactionResponse): Promise<TransactionReceipt>;
-    call<Request, Response, Output>(request: Executable<Request, Response, Output>): Promise<Output>;
-}

package/dist/lib/wallet/provider.js

@@ -1,58 +0,0 @@
-/*
- *
- * Hedera Wallet Connect
- *
- * Copyright (C) 2023 Hedera Hashgraph, LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-import { AccountBalanceQuery, AccountInfoQuery, AccountRecordsQuery, TransactionReceiptQuery, } from '@hashgraph/sdk';
-export default class Provider {
-    constructor(client) {
-        this.client = client;
-    }
-    static fromClient(client) {
-        return new Provider(client);
-    }
-    getLedgerId() {
-        return this.client.ledgerId;
-    }
-    getNetwork() {
-        return this.client.network;
-    }
-    getMirrorNetwork() {
-        return this.client.mirrorNetwork;
-    }
-    getAccountBalance(accountId) {
-        return new AccountBalanceQuery().setAccountId(accountId).execute(this.client);
-    }
-    getAccountInfo(accountId) {
-        return new AccountInfoQuery().setAccountId(accountId).execute(this.client);
-    }
-    getAccountRecords(accountId) {
-        return new AccountRecordsQuery().setAccountId(accountId).execute(this.client);
-    }
-    getTransactionReceipt(transactionId) {
-        return new TransactionReceiptQuery().setTransactionId(transactionId).execute(this.client);
-    }
-    waitForReceipt(response) {
-        return new TransactionReceiptQuery()
-            .setNodeAccountIds([response.nodeId])
-            .setTransactionId(response.transactionId)
-            .execute(this.client);
-    }
-    call(request) {
-        return request.execute(this.client);
-    }
-}

package/dist/lib/wallet/types.d.ts

@@ -1,31 +0,0 @@
-import type { WalletKitTypes } from '@reown/walletkit';
-import type { SessionTypes } from '@walletconnect/types';
-import type { Transaction, Query, AccountId, Wallet as HederaWallet } from '@hashgraph/sdk';
-import type { HederaJsonRpcMethod, HederaChainId } from '../shared';
-import type Provider from './provider';
-export interface HederaNativeWallet {
-    buildAndApproveSession(accounts: string[], { id, params }: WalletKitTypes.SessionProposal): Promise<SessionTypes.Struct>;
-    parseSessionRequest(event: WalletKitTypes.SessionRequest, shouldThrow: boolean): {
-        method: HederaJsonRpcMethod;
-        chainId: HederaChainId;
-        id: number;
-        topic: string;
-        body?: Transaction | Query<any> | string | Uint8Array | undefined;
-        accountId?: AccountId;
-    };
-    executeSessionRequest(event: WalletKitTypes.SessionRequest, hederaWallet: HederaWallet): Promise<void>;
-    rejectSessionRequest(event: WalletKitTypes.SessionRequest, error: {
-        code: number;
-        message: string;
-    }): Promise<void>;
-    getHederaWallet(chainId: HederaChainId, accountId: AccountId | string, privateKey: string, _provider?: Provider): HederaWallet;
-    [HederaJsonRpcMethod.GetNodeAddresses](id: number, topic: string, _: any, // ignore this param to be consistent call signature with other functions
-    signer: HederaWallet): Promise<void>;
-    [HederaJsonRpcMethod.ExecuteTransaction](id: number, topic: string, body: Transaction, signer: HederaWallet): Promise<void>;
-    [HederaJsonRpcMethod.SignMessage](id: number, topic: string, body: string, signer: HederaWallet): Promise<void>;
-    [HederaJsonRpcMethod.SignAndExecuteQuery](id: number, topic: string, body: Query<any>, signer: HederaWallet): Promise<void>;
-    [HederaJsonRpcMethod.SignAndExecuteTransaction](id: number, topic: string, body: Transaction, signer: HederaWallet): Promise<void>;
-    [HederaJsonRpcMethod.SignTransaction](id: number, topic: string, body: Uint8Array, signer: HederaWallet): Promise<void>;
-}
-export interface HederaEvmCompatibleWallet {
-}

package/dist/lib/wallet/types.js

@@ -1,20 +0,0 @@
-/*
- *
- * Hedera Wallet Connect
- *
- * Copyright (C) 2023 Hedera Hashgraph, LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-export {};

package/dist/reown/adapter.d.ts

@@ -1,59 +0,0 @@
-import { CaipNetwork } from '@reown/appkit';
-import { type ChainNamespace } from '@reown/appkit-common';
-import { AdapterBlueprint } from '@reown/appkit-controllers';
-type UniversalProvider = Parameters<AdapterBlueprint['setUniversalProvider']>[0];
-type AdapterSendTransactionParams = AdapterBlueprint.SendTransactionParams & {
-    address: string;
-};
-type GetEnsAddressParams = {
-    name: string;
-    caipNetwork?: CaipNetwork;
-};
-type GetEnsAddressResult = {
-    address: string | false;
-};
-type GetProfileResult = {
-    profileImage: string;
-    profileName: string;
-};
-export declare class HederaAdapter extends AdapterBlueprint {
-    private logger;
-    constructor(params: HederaAdapter.Params);
-    setUniversalProvider(universalProvider: UniversalProvider): Promise<void>;
-    connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
-    disconnect(_params?: AdapterBlueprint.DisconnectParams): Promise<AdapterBlueprint.DisconnectResult>;
-    getAccounts({ namespace, }: AdapterBlueprint.GetAccountsParams & {
-        namespace: ChainNamespace;
-    }): Promise<AdapterBlueprint.GetAccountsResult>;
-    syncConnectors(): Promise<void>;
-    syncConnections(_params: AdapterBlueprint.SyncConnectionsParams): Promise<void>;
-    getBalance(params: AdapterBlueprint.GetBalanceParams): Promise<AdapterBlueprint.GetBalanceResult>;
-    signMessage(params: AdapterBlueprint.SignMessageParams): Promise<AdapterBlueprint.SignMessageResult>;
-    estimateGas(params: AdapterBlueprint.EstimateGasTransactionArgs): Promise<AdapterBlueprint.EstimateGasTransactionResult>;
-    sendTransaction(params: AdapterSendTransactionParams): Promise<AdapterBlueprint.SendTransactionResult>;
-    writeContract(params: AdapterBlueprint.WriteContractParams): Promise<AdapterBlueprint.WriteContractResult>;
-    getEnsAddress(params: GetEnsAddressParams): Promise<GetEnsAddressResult>;
-    parseUnits(params: AdapterBlueprint.ParseUnitsParams): AdapterBlueprint.ParseUnitsResult;
-    formatUnits(params: AdapterBlueprint.FormatUnitsParams): AdapterBlueprint.FormatUnitsResult;
-    getCapabilities(params: AdapterBlueprint.GetCapabilitiesParams): Promise<unknown>;
-    getProfile(): Promise<GetProfileResult>;
-    grantPermissions(): Promise<unknown>;
-    revokePermissions(): Promise<`0x${string}`>;
-    syncConnection(params: AdapterBlueprint.SyncConnectionParams): Promise<{
-        id: string;
-        type: "WALLET_CONNECT";
-        chainId: string | number;
-        provider: UniversalProvider;
-        address: string;
-    }>;
-    switchNetwork(params: AdapterBlueprint.SwitchNetworkParams): Promise<void>;
-    protected getWalletConnectConnector(): ReturnType<AdapterBlueprint['getWalletConnectConnector']>;
-    getWalletConnectProvider(): UniversalProvider;
-    walletGetAssets(_params: AdapterBlueprint.WalletGetAssetsParams): Promise<AdapterBlueprint.WalletGetAssetsResponse>;
-}
-export declare namespace HederaAdapter {
-    type Params = AdapterBlueprint.Params & {
-        namespaceMode?: 'optional' | 'required';
-    };
-}
-export {};