@hashgraph/hedera-wallet-connect 2.0.1-canary.7e04cff.0 → 2.0.1-canary.8bde0e3.0

package/dist/reown/connectors/index.d.ts

@@ -0,0 +1 @@
+export * from './HederaConnector';

package/dist/reown/connectors/index.js

@@ -0,0 +1 @@
+export * from './HederaConnector';

package/dist/reown/index.d.ts

@@ -0,0 +1,4 @@
+export * from './adapter';
+export * from './providers';
+export * from './utils';
+export * from './wallets';

package/dist/reown/index.js

@@ -0,0 +1,4 @@
+export * from './adapter';
+export * from './providers';
+export * from './utils';
+export * from './wallets';

package/dist/reown/providers/EIP155Provider.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from 'events';
+import Client from '@walletconnect/sign-client';
+import { SessionTypes } from '@walletconnect/types';
+import { IProvider, SessionNamespace, RpcProvidersMap, RequestParams, Namespace } from '@walletconnect/universal-provider';
+declare class EIP155Provider implements IProvider {
+    name: string;
+    client: Client;
+    chainId: number;
+    namespace: SessionNamespace;
+    httpProviders: RpcProvidersMap;
+    events: EventEmitter;
+    constructor({ client, events, namespace, }: {
+        client: IProvider['client'];
+        events: EventEmitter;
+        namespace: Namespace;
+    });
+    request<T = unknown>(args: RequestParams): Promise<T>;
+    updateNamespace(namespace: SessionTypes.Namespace): void;
+    setDefaultChain(chainId: string, rpcUrl?: string | undefined): void;
+    requestAccounts(): string[];
+    getDefaultChain(): string;
+    private createHttpProvider;
+    private setHttpProvider;
+    private createHttpProviders;
+    private getAccounts;
+    private getHttpProvider;
+    private switchChain;
+    private isChainApproved;
+    private getCallStatus;
+    private getUserOperationReceipt;
+    private getBundlerUrl;
+}
+export default EIP155Provider;

package/dist/reown/providers/EIP155Provider.js

@@ -0,0 +1,187 @@
+import { JsonRpcProvider } from '@walletconnect/jsonrpc-provider';
+import { HttpConnection } from '@walletconnect/jsonrpc-http-connection';
+import { formatJsonRpcRequest } from '@walletconnect/jsonrpc-utils';
+import { BUNDLER_URL, getChainId, HederaChainDefinition } from '../utils';
+class EIP155Provider {
+    constructor({ client, events, namespace, }) {
+        this.name = 'eip155';
+        this.namespace = namespace;
+        this.events = events;
+        this.client = client;
+        this.httpProviders = this.createHttpProviders();
+        this.chainId = parseInt(this.getDefaultChain());
+    }
+    async request(args) {
+        switch (args.request.method) {
+            case 'eth_requestAccounts':
+                return this.getAccounts();
+            case 'eth_accounts':
+                return this.getAccounts();
+            case 'wallet_switchEthereumChain': {
+                return (await this.switchChain(args));
+            }
+            case 'eth_chainId':
+                return parseInt(this.getDefaultChain());
+            case 'wallet_getCallsStatus':
+                return (await this.getCallStatus(args));
+            default:
+                break;
+        }
+        if (this.namespace.methods.includes(args.request.method)) {
+            return await this.client.request(args);
+        }
+        return this.getHttpProvider().request(args.request);
+    }
+    updateNamespace(namespace) {
+        this.namespace = Object.assign(this.namespace, namespace);
+    }
+    setDefaultChain(chainId, rpcUrl) {
+        // http provider exists so just set the chainId
+        if (!this.httpProviders[chainId]) {
+            this.setHttpProvider(parseInt(chainId), rpcUrl);
+        }
+        this.chainId = parseInt(chainId);
+        this.events.emit('default_chain_changed', `${this.name}:${chainId}`);
+    }
+    requestAccounts() {
+        return this.getAccounts();
+    }
+    getDefaultChain() {
+        if (this.chainId)
+            return this.chainId.toString();
+        if (this.namespace.defaultChain)
+            return this.namespace.defaultChain;
+        const chainId = this.namespace.chains[0];
+        if (!chainId)
+            throw new Error(`ChainId not found`);
+        return chainId.split(':')[1];
+    }
+    // ---------- Private ----------------------------------------------- //
+    createHttpProvider(chainId, rpcUrl) {
+        if (!chainId)
+            return undefined;
+        const { Testnet, Mainnet } = HederaChainDefinition.EVM;
+        const caipNetwork = [Mainnet, Testnet].find((network) => network.id == chainId);
+        const rpc = (caipNetwork === null || caipNetwork === void 0 ? void 0 : caipNetwork.rpcUrls.default.http[0]) || rpcUrl;
+        if (!rpc) {
+            throw new Error(`No RPC url provided for chainId: ${chainId}`);
+        }
+        const http = new JsonRpcProvider(new HttpConnection(rpc, false));
+        return http;
+    }
+    setHttpProvider(chainId, rpcUrl) {
+        const http = this.createHttpProvider(chainId, rpcUrl);
+        if (http) {
+            this.httpProviders[chainId] = http;
+        }
+    }
+    createHttpProviders() {
+        const http = {};
+        this.namespace.chains.forEach((chain) => {
+            var _a;
+            const parsedChain = parseInt(getChainId(chain));
+            http[parsedChain] = this.createHttpProvider(parsedChain, (_a = this.namespace.rpcMap) === null || _a === void 0 ? void 0 : _a[chain]);
+        });
+        return http;
+    }
+    getAccounts() {
+        const accounts = this.namespace.accounts;
+        if (!accounts) {
+            return [];
+        }
+        return Array.from(new Set(accounts
+            .filter((account) => account.split(':')[1] === this.chainId.toString())
+            .map((account) => account.split(':')[2])));
+    }
+    getHttpProvider() {
+        const chain = this.chainId;
+        const http = this.httpProviders[chain];
+        if (typeof http === 'undefined') {
+            throw new Error(`JSON-RPC provider for ${chain} not found`);
+        }
+        return http;
+    }
+    async switchChain(args) {
+        var _a, _b;
+        let hexChainId = args.request.params
+            ? (_a = args.request.params[0]) === null || _a === void 0 ? void 0 : _a.chainId
+            : '0x0';
+        hexChainId = hexChainId.startsWith('0x') ? hexChainId : `0x${hexChainId}`;
+        const parsedChainId = parseInt(hexChainId, 16);
+        // if chainId is already approved, switch locally
+        if (this.isChainApproved(parsedChainId)) {
+            this.setDefaultChain(`${parsedChainId}`);
+        }
+        else if (this.namespace.methods.includes('wallet_switchEthereumChain')) {
+            // try to switch chain within the wallet
+            await this.client.request({
+                topic: args.topic,
+                request: {
+                    method: args.request.method,
+                    params: [
+                        {
+                            chainId: hexChainId,
+                        },
+                    ],
+                },
+                chainId: (_b = this.namespace.chains) === null || _b === void 0 ? void 0 : _b[0], // Sending a previously unapproved chainId will cause namespace validation failure so we must set request chainId to the first chainId in the namespace to avoid it
+            });
+            this.setDefaultChain(`${parsedChainId}`);
+        }
+        else {
+            throw new Error(`Failed to switch to chain 'eip155:${parsedChainId}'. The chain is not approved or the wallet does not support 'wallet_switchEthereumChain' method.`);
+        }
+        return null;
+    }
+    isChainApproved(chainId) {
+        return this.namespace.chains.includes(`${this.name}:${chainId}`);
+    }
+    async getCallStatus(args) {
+        var _a, _b;
+        const session = this.client.session.get(args.topic);
+        const bundlerName = (_a = session.sessionProperties) === null || _a === void 0 ? void 0 : _a.bundler_name;
+        if (bundlerName) {
+            const bundlerUrl = this.getBundlerUrl(args.chainId, bundlerName);
+            try {
+                return await this.getUserOperationReceipt(bundlerUrl, args);
+            }
+            catch (error) {
+                console.warn('Failed to fetch call status from bundler', error, bundlerUrl);
+            }
+        }
+        const customUrl = (_b = session.sessionProperties) === null || _b === void 0 ? void 0 : _b.bundler_url;
+        if (customUrl) {
+            try {
+                return await this.getUserOperationReceipt(customUrl, args);
+            }
+            catch (error) {
+                console.warn('Failed to fetch call status from custom bundler', error, customUrl);
+            }
+        }
+        if (this.namespace.methods.includes(args.request.method)) {
+            return await this.client.request(args);
+        }
+        throw new Error('Fetching call status not approved by the wallet.');
+    }
+    async getUserOperationReceipt(bundlerUrl, args) {
+        var _a, _b;
+        const url = new URL(bundlerUrl);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(formatJsonRpcRequest('eth_getUserOperationReceipt', [
+                (_b = (_a = args.request) === null || _a === void 0 ? void 0 : _a.params) === null || _b === void 0 ? void 0 : _b[0],
+            ])),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch user operation receipt - ${response.status}`);
+        }
+        return await response.json();
+    }
+    getBundlerUrl(cap2ChainId, bundlerName) {
+        return `${BUNDLER_URL}?projectId=${this.client.core.projectId}&chainId=${cap2ChainId}&bundler=${bundlerName}`;
+    }
+}
+export default EIP155Provider;

package/dist/reown/providers/HIP820Provider.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from 'events';
+import { DAppSigner } from '../..';
+import { SessionNamespace, RequestParams, IProvider } from '@walletconnect/universal-provider';
+import { SessionTypes } from '@walletconnect/types';
+import { Transaction } from '@hashgraph/sdk';
+declare class HIP820Provider implements IProvider {
+    events: EventEmitter;
+    client: IProvider['client'];
+    namespace: SessionNamespace;
+    chainId: string;
+    constructor(opts: {
+        namespace: SessionNamespace;
+        client: IProvider['client'];
+        events: EventEmitter;
+    });
+    get httpProviders(): {};
+    updateNamespace(namespace: SessionTypes.Namespace): void;
+    request<T = unknown>(args: RequestParams): Promise<T>;
+    signTransaction<T extends Transaction>(transaction: T, topic: string): Promise<T>;
+    requestAccounts(): string[];
+    setDefaultChain(chainId: string): void;
+    getDefaultChain(): string;
+    getSigner(topic: string): DAppSigner;
+    getSigners(topic: string): DAppSigner[];
+}
+export default HIP820Provider;

package/dist/reown/providers/HIP820Provider.js

@@ -0,0 +1,69 @@
+import { CAIPChainIdToLedgerId, DAppSigner } from '../..';
+import { AccountId } from '@hashgraph/sdk';
+class HIP820Provider {
+    constructor(opts) {
+        this.namespace = opts.namespace;
+        this.chainId = this.getDefaultChain();
+        this.events = opts.events;
+        this.client = opts.client;
+    }
+    get httpProviders() {
+        return {};
+    }
+    updateNamespace(namespace) {
+        this.namespace = Object.assign(this.namespace, namespace);
+    }
+    request(args) {
+        return this.getSigner(args.topic).request({
+            method: args.request.method,
+            params: args.request.params,
+        });
+    }
+    async signTransaction(transaction, topic) {
+        return this.getSigner(topic).signTransaction(transaction);
+    }
+    requestAccounts() {
+        const accounts = this.namespace.accounts;
+        if (!accounts) {
+            return [];
+        }
+        return Array.from(new Set(accounts
+            // get the accounts from the active chain
+            .filter((account) => account.split(':')[1] === this.chainId.toString())
+            // remove namespace & chainId from the string
+            .map((account) => account.split(':')[2])));
+    }
+    setDefaultChain(chainId) {
+        this.chainId = chainId;
+        this.namespace.defaultChain = chainId;
+    }
+    getDefaultChain() {
+        if (this.chainId)
+            return this.chainId;
+        if (this.namespace.defaultChain)
+            return this.namespace.defaultChain;
+        const chainId = this.namespace.chains[0];
+        if (!chainId)
+            throw new Error(`ChainId not found`);
+        return chainId.split(':')[1];
+    }
+    // create signer on demand
+    getSigner(topic) {
+        return this.getSigners(topic)[0];
+    }
+    getSigners(topic) {
+        var _a;
+        const accounts = (_a = this.namespace.accounts) === null || _a === void 0 ? void 0 : _a.map((account) => {
+            const [chain, network, acc] = account.split(':');
+            return {
+                ledgerId: CAIPChainIdToLedgerId(`${chain}:${network}`),
+                accountId: AccountId.fromString(acc),
+            };
+        });
+        if (!accounts) {
+            throw new Error('Accounts not found');
+        }
+        return accounts.map(({ accountId, ledgerId }) => new DAppSigner(accountId, this.client, topic, ledgerId));
+    }
+}
+export default HIP820Provider;

package/dist/reown/providers/HederaProvider.d.ts

@@ -0,0 +1,164 @@
+import { TransactionRequest } from 'ethers';
+import { CaipNetwork, RequestArguments } from '@reown/appkit';
+import type { EstimateGasTransactionArgs, SendTransactionArgs, WriteContractArgs } from '@reown/appkit';
+import UniversalProvider, { RpcProviderMap, UniversalProviderOpts } from '@walletconnect/universal-provider';
+import { Transaction } from '@hashgraph/sdk';
+import { ExecuteTransactionParams, SignMessageParams, SignAndExecuteQueryParams, SignAndExecuteTransactionParams, SignTransactionParams } from '../..';
+import { EthFilter } from '../utils';
+import HIP820Provider from './HIP820Provider';
+import EIP155Provider from './EIP155Provider';
+export type HederaWalletConnectProviderConfig = {
+    chains: CaipNetwork[];
+} & UniversalProviderOpts;
+export declare class HederaProvider extends UniversalProvider {
+    nativeProvider?: HIP820Provider;
+    eip155Provider?: EIP155Provider;
+    constructor(opts: UniversalProviderOpts);
+    static init(opts: UniversalProviderOpts): Promise<HederaProvider>;
+    emit(event: string, data?: unknown): void;
+    getAccountAddresses(): string[];
+    request<T = unknown>(args: RequestArguments, chain?: string | undefined, expiry?: number | undefined): Promise<T>;
+    /**
+     * Retrieves the node addresses associated with the current Hedera network.
+     *
+     * When there is no active session or an error occurs during the request.
+     * @returns Promise\<{@link GetNodeAddressesResult}\>
+     */
+    hedera_getNodeAddresses(): Promise<{
+        nodes: string[];
+    }>;
+    /**
+     * Executes a transaction on the Hedera network.
+     *
+     * @param {ExecuteTransactionParams} params - The parameters of type {@link ExecuteTransactionParams | `ExecuteTransactionParams`} required for the transaction execution.
+     * @param {string[]} params.signedTransaction - Array of Base64-encoded `Transaction`'s
+     * @returns Promise\<{@link ExecuteTransactionResult}\>
+     * @example
+     * Use helper `transactionToBase64String` to encode `Transaction` to Base64 string
+     * ```ts
+     * const params = {
+     *  signedTransaction: [transactionToBase64String(transaction)]
+     * }
+     *
+     * const result = await dAppConnector.executeTransaction(params)
+     * ```
+     */
+    hedera_executeTransaction(params: ExecuteTransactionParams): Promise<import("@hashgraph/sdk/lib/transaction/TransactionResponse").TransactionResponseJSON>;
+    /**
+     * Signs a provided `message` with provided `signerAccountId`.
+     *
+     * @param {SignMessageParams} params - The parameters of type {@link SignMessageParams | `SignMessageParams`} required for signing message.
+     * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
+     * @param {string} params.message - a plain UTF-8 string
+     * @returns Promise\<{@link SignMessageResult}\>
+     * @example
+     * ```ts
+     * const params = {
+     *  signerAccountId: 'hedera:testnet:0.0.12345',
+     *  message: 'Hello World!'
+     * }
+     *
+     * const result = await dAppConnector.signMessage(params)
+     * ```
+     */
+    hedera_signMessage(params: SignMessageParams): Promise<{
+        signatureMap: string;
+    }>;
+    /**
+     * Signs and send `Query` on the Hedera network.
+     *
+     * @param {SignAndExecuteQueryParams} params - The parameters of type {@link SignAndExecuteQueryParams | `SignAndExecuteQueryParams`} required for the Query execution.
+     * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
+     * @param {string} params.query - `Query` object represented as Base64 string
+     * @returns Promise\<{@link SignAndExecuteQueryResult}\>
+     * @example
+     * Use helper `queryToBase64String` to encode `Query` to Base64 string
+     * ```ts
+     * const params = {
+     *  signerAccountId: '0.0.12345',
+     *  query: queryToBase64String(query),
+     * }
+     *
+     * const result = await dAppConnector.signAndExecuteQuery(params)
+     * ```
+     */
+    hedera_signAndExecuteQuery(params: SignAndExecuteQueryParams): Promise<{
+        response: string;
+    }>;
+    /**
+     * Signs and executes Transactions on the Hedera network.
+     *
+     * @param {SignAndExecuteTransactionParams} params - The parameters of type {@link SignAndExecuteTransactionParams | `SignAndExecuteTransactionParams`} required for `Transaction` signing and execution.
+     * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
+     * @param {string[]} params.transaction - Array of Base64-encoded `Transaction`'s
+     * @returns Promise\<{@link SignAndExecuteTransactionResult}\>
+     * @example
+     * Use helper `transactionToBase64String` to encode `Transaction` to Base64 string
+     * ```ts
+     * const params = {
+     *  signerAccountId: '0.0.12345'
+     *  transaction: [transactionToBase64String(transaction)]
+     * }
+     *
+     * const result = await dAppConnector.signAndExecuteTransaction(params)
+     * ```
+     */
+    hedera_signAndExecuteTransaction(params: SignAndExecuteTransactionParams): Promise<import("@hashgraph/sdk/lib/transaction/TransactionResponse").TransactionResponseJSON>;
+    /**
+     * Signs and executes Transactions on the Hedera network.
+     *
+     * @param {SignTransactionParams} params - The parameters of type {@link SignTransactionParams | `SignTransactionParams`} required for `Transaction` signing.
+     * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
+     * @param {Transaction} params.transactionBody - a Transaction object built with the @hgraph/sdk
+     * @returns Promise\<{@link SignTransactionResult}\>
+     * @example
+     * ```ts
+     *
+     * const params = {
+     *  signerAccountId: '0.0.12345',
+     *  transactionBody
+     * }
+     *
+     * const result = await dAppConnector.signTransaction(params)
+     * ```
+     */
+    hedera_signTransaction(params: SignTransactionParams): Promise<Transaction>;
+    eth_signMessage(message: string, address: string): Promise<`0x${string}`>;
+    eth_estimateGas(data: EstimateGasTransactionArgs, address: string, networkId: number): Promise<bigint>;
+    eth_sendTransaction(data: SendTransactionArgs, address: string, networkId: number): Promise<`0x${string}`>;
+    eth_writeContract(data: WriteContractArgs, address: string, chainId: number): Promise<string>;
+    eth_blockNumber(): Promise<string>;
+    eth_call(tx: TransactionRequest, block?: string): Promise<string>;
+    eth_feeHistory(blockCount: number, newestBlock: string, rewardPercentiles: number[]): Promise<string>;
+    eth_gasPrice(): Promise<string>;
+    eth_getBlockByHash(hash: string, fullTx?: boolean): Promise<string>;
+    eth_getBlockByNumber(block: string, fullTx?: boolean): Promise<unknown>;
+    eth_getBlockTransactionCountByHash(hash: string): Promise<string>;
+    eth_getBlockTransactionCountByNumber(block: string): Promise<string>;
+    eth_getCode(address: string, block?: string): Promise<string>;
+    eth_getFilterLogs(filterId: string): Promise<string>;
+    eth_getFilterChanges(filterId: string): Promise<string>;
+    eth_getLogs(filter: EthFilter): Promise<string>;
+    eth_getStorageAt(address: string, position: string, block?: string): Promise<string>;
+    eth_getTransactionByBlockHashAndIndex(hash: string, index: string): Promise<string>;
+    eth_getTransactionByBlockNumberAndIndex(block: string, index: string): Promise<string>;
+    eth_getTransactionByHash(hash: string): Promise<string>;
+    eth_getTransactionCount(address: string, block?: string): Promise<string>;
+    eth_getTransactionReceipt(hash: string): Promise<string>;
+    eth_hashrate(): Promise<string>;
+    eth_maxPriorityFeePerGas(): Promise<string>;
+    eth_mining(): Promise<string>;
+    eth_newBlockFilter(): Promise<string>;
+    eth_newFilter(filter: EthFilter): Promise<string>;
+    eth_submitWork(params: string[]): Promise<string>;
+    eth_syncing(): Promise<string>;
+    eth_uninstallFilter(filterId: string): Promise<string>;
+    net_listening(): Promise<string>;
+    net_version(): Promise<string>;
+    web3_clientVersion(): Promise<string>;
+    eth_chainId(): Promise<string>;
+    pair(pairingTopic: string | undefined): ReturnType<UniversalProvider['pair']>;
+    private initProviders;
+    get rpcProviders(): RpcProviderMap;
+    set rpcProviders(_: RpcProviderMap);
+}