@hashgraph/hedera-wallet-connect 1.5.2-canary.dd48df1.0 → 2.0.0-canary.45f2441.0

package/dist/lib/shared/utils.d.ts

@@ -1,28 +1,10 @@
 import { AccountId, PublicKey, Transaction, LedgerId, Query, SignerSignature } from '@hashgraph/sdk';
 import { ProposalTypes, SessionTypes } from '@walletconnect/types';
 import { proto } from '@hashgraph/proto';
-/**
- * Freezes a transaction if it is not already frozen. Transactions must
- * be frozen before they can be converted to bytes.
- *
- * @param transaction - Any instance of a class that extends `Transaction`
- */
-export declare function freezeTransaction<T extends Transaction>(transaction: T): void;
-/**
- * Sets default consensus nodes that a transaction will be submitted to. Node Account ID(s)
- * must be set before a transaction can be frozen. If they have already been set, this
- * function will not modify the transaction.
- * @param transaction - any instance of a class that extends `Transaction`
- *
- * @see {@link https://docs.hedera.com/hedera/networks/testnet/testnet-nodes | Full list of Testnet-nodes}
- * @see {@link https://docs.hedera.com/hedera/networks/mainnet/mainnet-nodes | Full list of Mainnet-nodes}
- */
-export declare function setDefaultNodeAccountIds<T extends Transaction>(transaction: T): void;
 /**
  * Converts `Transaction` to a Base64-string.
  *
- * First converts a transaction to bytes and then encodes it as a Base64-string. Will attempt
- * to set default Node Account ID and freeze the transaction before converting.
+ * Converts a transaction to bytes and then encodes it as a Base64-string. Allow uncompleted transaction (HIP-745).
  * @param transaction - Any instance of a class that extends `Transaction`
  * @returns Base64 encoded representation of the input `Transaction` object
  */
@@ -49,7 +31,7 @@ export declare function base64StringToTransaction<T extends Transaction>(transac
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
  * @returns `string`
  * */
-export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId: AccountId): any;
+export declare function transactionToTransactionBody<T extends Transaction>(transaction: T): any;
 export declare function transactionBodyToBase64String(transactionBody: proto.ITransactionBody): string;
 /**
  * @param transactionList - a proto.TransactionList object

package/dist/lib/shared/utils.js

@@ -20,41 +20,14 @@
 import { Buffer } from 'buffer';
 import { AccountId, Transaction, LedgerId, Query, } from '@hashgraph/sdk';
 import { proto } from '@hashgraph/proto';
-/**
- * Freezes a transaction if it is not already frozen. Transactions must
- * be frozen before they can be converted to bytes.
- *
- * @param transaction - Any instance of a class that extends `Transaction`
- */
-export function freezeTransaction(transaction) {
-    if (!transaction.isFrozen())
-        transaction.freeze();
-}
-/**
- * Sets default consensus nodes that a transaction will be submitted to. Node Account ID(s)
- * must be set before a transaction can be frozen. If they have already been set, this
- * function will not modify the transaction.
- * @param transaction - any instance of a class that extends `Transaction`
- *
- * @see {@link https://docs.hedera.com/hedera/networks/testnet/testnet-nodes | Full list of Testnet-nodes}
- * @see {@link https://docs.hedera.com/hedera/networks/mainnet/mainnet-nodes | Full list of Mainnet-nodes}
- */
-export function setDefaultNodeAccountIds(transaction) {
-    const isNodeAccountIdNotSet = !transaction.nodeAccountIds || transaction.nodeAccountIds.length === 0;
-    if (!transaction.isFrozen() && isNodeAccountIdNotSet)
-        transaction.setNodeAccountIds([new AccountId(3), new AccountId(4), new AccountId(5)]);
-}
 /**
  * Converts `Transaction` to a Base64-string.
  *
- * First converts a transaction to bytes and then encodes it as a Base64-string. Will attempt
- * to set default Node Account ID and freeze the transaction before converting.
+ * Converts a transaction to bytes and then encodes it as a Base64-string. Allow uncompleted transaction (HIP-745).
  * @param transaction - Any instance of a class that extends `Transaction`
  * @returns Base64 encoded representation of the input `Transaction` object
  */
 export function transactionToBase64String(transaction) {
-    setDefaultNodeAccountIds(transaction);
-    freezeTransaction(transaction);
     const transactionBytes = transaction.toBytes();
     return Buffer.from(transactionBytes).toString('base64');
 }
@@ -83,10 +56,10 @@ export function base64StringToTransaction(transactionBytes) {
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
  * @returns `string`
  * */
-export function transactionToTransactionBody(transaction, nodeAccountId) {
+export function transactionToTransactionBody(transaction) {
     // This is a private function, though provides the capabilities to construct a proto.TransactionBody
     //@ts-ignore
-    return transaction._makeTransactionBody(nodeAccountId);
+    return transaction._makeTransactionBody(null);
 }
 export function transactionBodyToBase64String(transactionBody) {
     return Uint8ArrayToBase64String(proto.TransactionBody.encode(transactionBody).finish());

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

@@ -1,4 +1,4 @@
-import { Web3Wallet, Web3WalletTypes } from '@walletconnect/web3wallet';
+import { WalletKit, WalletKitTypes } from '@reown/walletkit';
 import { SessionTypes } from '@walletconnect/types';
 import { Wallet as HederaWallet, AccountId, Transaction, Query } from '@hashgraph/sdk';
 import { HederaChainId, HederaSessionEvent, HederaJsonRpcMethod } from '../shared';
@@ -6,16 +6,16 @@ import Provider from './provider';
 import type { HederaNativeWallet } from './types';
 export type { HederaNativeWallet } from './types';
 export { default as WalletProvider } from './provider';
-export declare class HederaWeb3Wallet extends Web3Wallet implements HederaNativeWallet {
+export declare class HederaWeb3Wallet extends WalletKit implements HederaNativeWallet {
     chains: HederaChainId[] | string[];
     methods: string[];
     sessionEvents: HederaSessionEvent[] | string[];
-    constructor(opts: Web3WalletTypes.Options, chains?: HederaChainId[] | string[], methods?: string[], sessionEvents?: HederaSessionEvent[] | string[]);
-    static create(projectId: string, metadata: Web3WalletTypes.Metadata, chains?: HederaChainId[], methods?: string[], sessionEvents?: HederaSessionEvent[] | string[]): Promise<HederaWeb3Wallet>;
+    constructor(opts: WalletKitTypes.Options, chains?: HederaChainId[] | string[], methods?: string[], sessionEvents?: HederaSessionEvent[] | string[]);
+    static create(projectId: string, metadata: WalletKitTypes.Metadata, chains?: HederaChainId[], methods?: string[], sessionEvents?: HederaSessionEvent[] | string[]): Promise<HederaWeb3Wallet>;
     getHederaWallet(chainId: HederaChainId, accountId: AccountId | string, privateKey: string, _provider?: Provider): HederaWallet;
-    buildAndApproveSession(accounts: string[], { id, params }: Web3WalletTypes.SessionProposal): Promise<SessionTypes.Struct>;
+    buildAndApproveSession(accounts: string[], { id, params }: WalletKitTypes.SessionProposal): Promise<SessionTypes.Struct>;
     validateParam(name: string, value: any, expectedType: string): void;
-    parseSessionRequest(event: Web3WalletTypes.SessionRequest, shouldThrow?: boolean): {
+    parseSessionRequest(event: WalletKitTypes.SessionRequest, shouldThrow?: boolean): {
         method: HederaJsonRpcMethod;
         chainId: HederaChainId;
         id: number;
@@ -23,8 +23,8 @@ export declare class HederaWeb3Wallet extends Web3Wallet implements HederaNative
         body?: Transaction | Query<any> | string | Uint8Array | undefined;
         accountId?: AccountId;
     };
-    executeSessionRequest(event: Web3WalletTypes.SessionRequest, hederaWallet: HederaWallet): Promise<void>;
-    rejectSessionRequest(event: Web3WalletTypes.SessionRequest, error: {
+    executeSessionRequest(event: WalletKitTypes.SessionRequest, hederaWallet: HederaWallet): Promise<void>;
+    rejectSessionRequest(event: WalletKitTypes.SessionRequest, error: {
         code: number;
         message: string;
     }): Promise<void>;

package/dist/lib/wallet/index.js

@@ -19,7 +19,7 @@
  */
 import { Buffer } from 'buffer';
 import { Core } from '@walletconnect/core';
-import { Web3Wallet } from '@walletconnect/web3wallet';
+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';
@@ -30,7 +30,7 @@ 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 Web3Wallet {
+export class HederaWeb3Wallet extends WalletKit {
     /*
      * Set default values for chains, methods, events
      */
@@ -269,6 +269,11 @@ export class HederaWeb3Wallet extends Web3Wallet {
     }
     // 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,

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

@@ -1,11 +1,11 @@
-import type { Web3WalletTypes } from '@walletconnect/web3wallet';
+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 }: Web3WalletTypes.SessionProposal): Promise<SessionTypes.Struct>;
-    parseSessionRequest(event: Web3WalletTypes.SessionRequest, shouldThrow: boolean): {
+    buildAndApproveSession(accounts: string[], { id, params }: WalletKitTypes.SessionProposal): Promise<SessionTypes.Struct>;
+    parseSessionRequest(event: WalletKitTypes.SessionRequest, shouldThrow: boolean): {
         method: HederaJsonRpcMethod;
         chainId: HederaChainId;
         id: number;
@@ -13,8 +13,8 @@ export interface HederaNativeWallet {
         body?: Transaction | Query<any> | string | Uint8Array | undefined;
         accountId?: AccountId;
     };
-    executeSessionRequest(event: Web3WalletTypes.SessionRequest, hederaWallet: HederaWallet): Promise<void>;
-    rejectSessionRequest(event: Web3WalletTypes.SessionRequest, error: {
+    executeSessionRequest(event: WalletKitTypes.SessionRequest, hederaWallet: HederaWallet): Promise<void>;
+    rejectSessionRequest(event: WalletKitTypes.SessionRequest, error: {
         code: number;
         message: string;
     }): Promise<void>;

package/dist/reown/adapter.d.ts

@@ -0,0 +1,37 @@
+import { type ChainNamespace } from '@reown/appkit-common';
+import { AdapterBlueprint } from '@reown/appkit/adapters';
+type UniversalProvider = Parameters<AdapterBlueprint['setUniversalProvider']>[0];
+export declare class HederaAdapter extends AdapterBlueprint {
+    constructor(params: AdapterBlueprint.Params);
+    setUniversalProvider(universalProvider: UniversalProvider): void;
+    connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
+    disconnect(): Promise<void>;
+    getAccounts({ namespace, }: AdapterBlueprint.GetAccountsParams & {
+        namespace: ChainNamespace;
+    }): Promise<AdapterBlueprint.GetAccountsResult>;
+    syncConnectors(): 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: AdapterBlueprint.SendTransactionParams): Promise<AdapterBlueprint.SendTransactionResult>;
+    writeContract(params: AdapterBlueprint.WriteContractParams): Promise<AdapterBlueprint.WriteContractResult>;
+    getEnsAddress(params: AdapterBlueprint.GetEnsAddressParams): Promise<AdapterBlueprint.GetEnsAddressResult>;
+    parseUnits(params: AdapterBlueprint.ParseUnitsParams): AdapterBlueprint.ParseUnitsResult;
+    formatUnits(params: AdapterBlueprint.FormatUnitsParams): AdapterBlueprint.FormatUnitsResult;
+    getCapabilities(params: AdapterBlueprint.GetCapabilitiesParams): Promise<unknown>;
+    getProfile(): Promise<AdapterBlueprint.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 {};

package/dist/reown/adapter.js

@@ -0,0 +1,255 @@
+import { CoreHelperUtil, WcHelpersUtil } from '@reown/appkit';
+import { isReownName } from '@reown/appkit-common';
+import { AdapterBlueprint } from '@reown/appkit/adapters';
+import { ProviderUtil } from '@reown/appkit/store';
+import { LedgerId } from '@hashgraph/sdk';
+import { BrowserProvider, Contract, formatUnits, JsonRpcSigner, parseUnits } from 'ethers';
+import { HederaConnector } from './connectors';
+import { hederaNamespace } from './utils';
+import { getAccountInfo } from '..';
+export class HederaAdapter extends AdapterBlueprint {
+    constructor(params) {
+        var _a, _b;
+        if (params.namespace !== hederaNamespace && params.namespace !== 'eip155') {
+            throw new Error('Namespace must be "hedera" or "eip155"');
+        }
+        if (params.namespace == 'eip155') {
+            if ((_a = params.networks) === null || _a === void 0 ? void 0 : _a.some((n) => n.chainNamespace != 'eip155')) {
+                throw new Error('Invalid networks for eip155 namespace');
+            }
+        }
+        else {
+            if ((_b = params.networks) === null || _b === void 0 ? void 0 : _b.some((n) => n.chainNamespace != hederaNamespace)) {
+                throw new Error('Invalid networks for hedera namespace');
+            }
+        }
+        super(Object.assign({}, params));
+    }
+    setUniversalProvider(universalProvider) {
+        this.addConnector(new HederaConnector({
+            provider: universalProvider,
+            caipNetworks: this.caipNetworks || [],
+            namespace: this.namespace,
+        }));
+    }
+    async connect(params) {
+        return Promise.resolve({
+            id: 'WALLET_CONNECT',
+            type: 'WALLET_CONNECT',
+            chainId: Number(params.chainId),
+            provider: this.provider,
+            address: '',
+        });
+    }
+    async disconnect() {
+        try {
+            const connector = this.getWalletConnectConnector();
+            await connector.disconnect();
+        }
+        catch (error) {
+            console.warn('UniversalAdapter:disconnect - error', error);
+        }
+    }
+    async getAccounts({ namespace, }) {
+        var _a, _b, _c, _d;
+        const provider = this.provider;
+        const addresses = (((_d = (_c = (_b = (_a = provider === null || provider === void 0 ? void 0 : provider.session) === null || _a === void 0 ? void 0 : _a.namespaces) === null || _b === void 0 ? void 0 : _b[namespace]) === null || _c === void 0 ? void 0 : _c.accounts) === null || _d === void 0 ? void 0 : _d.map((account) => {
+            const [, , address] = account.split(':');
+            return address;
+        }).filter((address, index, self) => self.indexOf(address) === index)) || []);
+        return Promise.resolve({
+            accounts: addresses.map((address) => CoreHelperUtil.createAccount(namespace, address, 'eoa')),
+        });
+    }
+    async syncConnectors() {
+        return Promise.resolve();
+    }
+    async getBalance(params) {
+        const { address, caipNetwork } = params;
+        if (!caipNetwork) {
+            return Promise.resolve({
+                balance: '0',
+                decimals: 0,
+                symbol: '',
+            });
+        }
+        const accountInfo = await getAccountInfo(caipNetwork.testnet ? LedgerId.TESTNET : LedgerId.MAINNET, address);
+        return Promise.resolve({
+            balance: (accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.balance)
+                ? formatUnits(accountInfo.balance.balance, 8).toString()
+                : '0',
+            decimals: caipNetwork.nativeCurrency.decimals,
+            symbol: caipNetwork.nativeCurrency.symbol,
+        });
+    }
+    async signMessage(params) {
+        const { provider, message, address } = params;
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        const hederaProvider = provider;
+        let signature = '';
+        if (this.namespace === hederaNamespace) {
+            const response = await hederaProvider.hedera_signMessage({
+                signerAccountId: address,
+                message,
+            });
+            signature = response.signatureMap;
+        }
+        else {
+            signature = await hederaProvider.eth_signMessage(message, address);
+        }
+        return { signature };
+    }
+    async estimateGas(params) {
+        const { provider, caipNetwork, address } = params;
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        const hederaProvider = provider;
+        const result = await hederaProvider.eth_estimateGas({
+            data: params.data,
+            to: params.to,
+            address: address,
+        }, address, Number(caipNetwork === null || caipNetwork === void 0 ? void 0 : caipNetwork.id));
+        return { gas: result };
+    }
+    async sendTransaction(params) {
+        var _a;
+        if (!params.provider) {
+            throw new Error('Provider is undefined');
+        }
+        const hederaProvider = params.provider;
+        if (this.namespace == 'eip155') {
+            const tx = await hederaProvider.eth_sendTransaction({
+                value: params.value,
+                to: params.to,
+                data: params.data,
+                gas: params.gas,
+                gasPrice: params.gasPrice,
+                address: params.address,
+            }, params.address, Number((_a = params.caipNetwork) === null || _a === void 0 ? void 0 : _a.id));
+            return { hash: tx };
+        }
+        else {
+            throw new Error('Namespace is not eip155');
+        }
+    }
+    async writeContract(params) {
+        if (!params.provider) {
+            throw new Error('Provider is undefined');
+        }
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        const { provider, caipNetwork, caipAddress, abi, tokenAddress, method, args } = params;
+        const browserProvider = new BrowserProvider(provider, Number(caipNetwork === null || caipNetwork === void 0 ? void 0 : caipNetwork.id));
+        const signer = new JsonRpcSigner(browserProvider, caipAddress);
+        const contract = new Contract(tokenAddress, abi, signer);
+        if (!contract || !method) {
+            throw new Error('Contract method is undefined');
+        }
+        const contractMethod = contract[method];
+        if (contractMethod) {
+            const result = await contractMethod(...args);
+            return { hash: result };
+        }
+        else
+            throw new Error('Contract method is undefined');
+    }
+    async getEnsAddress(params) {
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        const { name, caipNetwork } = params;
+        if (caipNetwork) {
+            if (isReownName(name)) {
+                return {
+                    address: (await WcHelpersUtil.resolveReownName(name)) || false,
+                };
+            }
+        }
+        return { address: false };
+    }
+    parseUnits(params) {
+        return parseUnits(params.value, params.decimals);
+    }
+    formatUnits(params) {
+        return formatUnits(params.value, params.decimals);
+    }
+    async getCapabilities(params) {
+        var _a, _b;
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        const provider = ProviderUtil.getProvider('eip155');
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        const walletCapabilitiesString = (_b = (_a = provider.session) === null || _a === void 0 ? void 0 : _a.sessionProperties) === null || _b === void 0 ? void 0 : _b['capabilities'];
+        if (walletCapabilitiesString) {
+            try {
+                const walletCapabilities = JSON.parse(walletCapabilitiesString);
+                const accountCapabilities = walletCapabilities[params];
+                if (accountCapabilities) {
+                    return accountCapabilities;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                throw new Error('Error parsing wallet capabilities');
+            }
+        }
+        return await provider.request({
+            method: 'wallet_getCapabilities',
+            params: [params],
+        });
+    }
+    // Not supported
+    async getProfile() {
+        return Promise.resolve({
+            profileImage: '',
+            profileName: '',
+        });
+    }
+    // Not supported
+    async grantPermissions() {
+        return Promise.resolve({});
+    }
+    // Not supported
+    async revokePermissions() {
+        return Promise.resolve('0x');
+    }
+    async syncConnection(params) {
+        return Promise.resolve({
+            id: 'WALLET_CONNECT',
+            type: 'WALLET_CONNECT',
+            chainId: params.chainId,
+            provider: this.provider,
+            address: '',
+        });
+    }
+    async switchNetwork(params) {
+        const { caipNetwork } = params;
+        const connector = this.getWalletConnectConnector();
+        connector.provider.setDefaultChain(caipNetwork.caipNetworkId);
+    }
+    getWalletConnectConnector() {
+        const connector = this.connectors.find((c) => c.type == 'WALLET_CONNECT');
+        if (!connector) {
+            throw new Error('WalletConnectConnector not found');
+        }
+        return connector;
+    }
+    getWalletConnectProvider() {
+        const connector = this.connectors.find((c) => c.type === 'WALLET_CONNECT');
+        const provider = connector === null || connector === void 0 ? void 0 : connector.provider;
+        return provider;
+    }
+    async walletGetAssets(_params) {
+        return Promise.resolve({});
+    }
+}

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

@@ -0,0 +1,29 @@
+import type { SessionTypes } from '@walletconnect/types';
+import { CaipNetwork, ChainNamespace } from '@reown/appkit-common';
+import { AdapterBlueprint, type ChainAdapterConnector } from '@reown/appkit/adapters';
+type UniversalProvider = Parameters<AdapterBlueprint['setUniversalProvider']>[0];
+export declare class HederaConnector implements ChainAdapterConnector {
+    readonly id: "walletConnect";
+    readonly name: string;
+    readonly type = "WALLET_CONNECT";
+    readonly imageId: string;
+    readonly chain: ChainNamespace;
+    provider: UniversalProvider;
+    protected caipNetworks: CaipNetwork[];
+    constructor({ provider, caipNetworks, namespace }: HederaConnector.Options);
+    get chains(): CaipNetwork[];
+    connectWalletConnect(): Promise<{
+        clientId: string;
+        session: SessionTypes.Struct;
+    }>;
+    disconnect(): Promise<void>;
+    authenticate(): Promise<boolean>;
+}
+export declare namespace HederaConnector {
+    type Options = {
+        provider: UniversalProvider;
+        caipNetworks: CaipNetwork[];
+        namespace: 'hedera' | 'eip155';
+    };
+}
+export {};

package/dist/reown/connectors/HederaConnector.js

@@ -0,0 +1,35 @@
+import { ConstantsUtil } from '@reown/appkit-common';
+import { PresetsUtil } from '@reown/appkit-utils';
+import { createNamespaces } from '../utils';
+export class HederaConnector {
+    constructor({ provider, caipNetworks, namespace }) {
+        this.id = ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
+        this.name = PresetsUtil.ConnectorNamesMap[ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT];
+        this.type = 'WALLET_CONNECT';
+        this.imageId = PresetsUtil.ConnectorImageIds[ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT];
+        this.caipNetworks = caipNetworks;
+        this.provider = provider;
+        this.chain = namespace;
+    }
+    get chains() {
+        return this.caipNetworks;
+    }
+    async connectWalletConnect() {
+        const isAuthenticated = await this.authenticate();
+        if (!isAuthenticated) {
+            await this.provider.connect({
+                optionalNamespaces: createNamespaces(this.caipNetworks),
+            });
+        }
+        return {
+            clientId: await this.provider.client.core.crypto.getClientId(),
+            session: this.provider.session,
+        };
+    }
+    async disconnect() {
+        await this.provider.disconnect();
+    }
+    async authenticate() {
+        return false;
+    }
+}

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/universal-provider/node_modules/@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;