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

package/dist/reown/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gets message from various signing request methods by filtering out
+ * a value that is not an address (thus is a message).
+ * If it is a hex string, it gets converted to utf8 string
+ */
+export declare function getSignParamsMessage(params: string[]): string;
+/**
+ * Gets data from various signTypedData request methods by filtering out
+ * a value that is not an address (thus is data).
+ * If data is a string convert it to object
+ */
+export declare function getSignTypedDataParamsData(params: string[]): any;

package/dist/reown/utils/helpers.js

@@ -0,0 +1,25 @@
+import { ethers } from 'ethers';
+/**
+ * Gets message from various signing request methods by filtering out
+ * a value that is not an address (thus is a message).
+ * If it is a hex string, it gets converted to utf8 string
+ */
+export function getSignParamsMessage(params) {
+    const message = params.filter((p) => !ethers.isAddress(p))[0];
+    if (ethers.isHexString(message)) {
+        return ethers.toUtf8String(message);
+    }
+    return message;
+}
+/**
+ * Gets data from various signTypedData request methods by filtering out
+ * a value that is not an address (thus is data).
+ * If data is a string convert it to object
+ */
+export function getSignTypedDataParamsData(params) {
+    const data = params.filter((p) => !ethers.isAddress(p))[0];
+    if (typeof data === 'string') {
+        return JSON.parse(data);
+    }
+    return data;
+}

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

@@ -0,0 +1,4 @@
+export * from './chains';
+export * from './constants';
+export * from './types';
+export * from './helpers';

package/dist/reown/utils/index.js

@@ -0,0 +1,4 @@
+export * from './chains';
+export * from './constants';
+export * from './types';
+export * from './helpers';

package/dist/reown/utils/types.d.ts

@@ -0,0 +1,9 @@
+import { SignClientTypes } from '@walletconnect/types';
+export interface EthFilter {
+    address?: string;
+    topics?: Array<string | null>;
+    fromBlock?: string;
+    toBlock?: string;
+    blockHash?: string;
+}
+export type WalletRequestEventArgs = Omit<SignClientTypes.EventArguments['session_request'], 'verifyContext'>;

package/dist/reown/utils/types.js

@@ -0,0 +1 @@
+export {};

package/dist/reown/wallets/EIP155Wallet.d.ts

@@ -0,0 +1,46 @@
+import { JsonRpcProvider, BaseWallet as BaseEvmWallet, TransactionResponse, JsonRpcTransactionRequest } from 'ethers';
+import { JsonRpcError, JsonRpcResult } from '@walletconnect/jsonrpc-utils';
+import { Eip155JsonRpcMethod, WalletRequestEventArgs } from '..';
+/**
+ * Types
+ */
+interface IInitArgs {
+    privateKey?: string;
+}
+export interface EIP155WalletInterface {
+    getPrivateKey(): string;
+    getEvmAddress(): string;
+    connect(provider: JsonRpcProvider): BaseEvmWallet;
+    approveSessionRequest(requestEvent: WalletRequestEventArgs): Promise<JsonRpcResult<any> | JsonRpcError>;
+    rejectSessionRequest(requestEvent: WalletRequestEventArgs): JsonRpcError;
+    [Eip155JsonRpcMethod.PersonalSign](message: string): Promise<string>;
+    [Eip155JsonRpcMethod.Sign](message: string): Promise<string>;
+    [Eip155JsonRpcMethod.SignTypedData](domain: any, types: any, data: any): Promise<string>;
+    [Eip155JsonRpcMethod.SignTypedDataV3](domain: any, types: any, data: any): Promise<string>;
+    [Eip155JsonRpcMethod.SignTypedDataV4](domain: any, types: any, data: any): Promise<string>;
+    [Eip155JsonRpcMethod.SignTransaction](transaction: JsonRpcTransactionRequest, provider: JsonRpcProvider): Promise<string>;
+    [Eip155JsonRpcMethod.SendTransaction](transaction: JsonRpcTransactionRequest, provider: JsonRpcProvider): Promise<TransactionResponse>;
+    [Eip155JsonRpcMethod.SendRawTransaction](rawTransaction: string, provider: JsonRpcProvider): Promise<TransactionResponse>;
+}
+/**
+ * Library
+ */
+export declare class EIP155Wallet implements EIP155WalletInterface {
+    wallet: BaseEvmWallet;
+    constructor(wallet: BaseEvmWallet);
+    connect(provider: JsonRpcProvider): BaseEvmWallet;
+    personal_sign(message: string): Promise<string>;
+    eth_sign(message: string): Promise<string>;
+    eth_signTypedData(domain: any, types: any, data: any): Promise<string>;
+    eth_signTypedData_v3(domain: any, types: any, data: any): Promise<string>;
+    eth_signTypedData_v4(domain: any, types: any, data: any): Promise<string>;
+    eth_signTransaction(transaction: JsonRpcTransactionRequest, provider: JsonRpcProvider): Promise<string>;
+    eth_sendTransaction(transaction: JsonRpcTransactionRequest, provider: JsonRpcProvider): Promise<TransactionResponse>;
+    eth_sendRawTransaction(rawTransaction: string, provider: JsonRpcProvider): Promise<TransactionResponse>;
+    static init({ privateKey }: IInitArgs): EIP155Wallet;
+    getPrivateKey(): string;
+    getEvmAddress(): string;
+    approveSessionRequest(requestEvent: WalletRequestEventArgs): Promise<JsonRpcError | JsonRpcResult<string>>;
+    rejectSessionRequest(requestEvent: WalletRequestEventArgs): JsonRpcError;
+}
+export {};

package/dist/reown/wallets/EIP155Wallet.js

@@ -0,0 +1,124 @@
+import { JsonRpcProvider, Wallet, Transaction, } from 'ethers';
+import { formatJsonRpcError, formatJsonRpcResult, } from '@walletconnect/jsonrpc-utils';
+import { getSdkError } from '@walletconnect/utils';
+import { Eip155JsonRpcMethod, HederaChainDefinition, getSignParamsMessage, getSignTypedDataParamsData, } from '..';
+/**
+ * Library
+ */
+export class EIP155Wallet {
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    connect(provider) {
+        return this.wallet.connect(provider);
+    }
+    personal_sign(message) {
+        return this.eth_sign(message);
+    }
+    eth_sign(message) {
+        return this.wallet.signMessage(message);
+    }
+    eth_signTypedData(domain, types, data) {
+        return this.wallet.signTypedData(domain, types, data);
+    }
+    eth_signTypedData_v3(domain, types, data) {
+        return this.eth_signTypedData(domain, types, data);
+    }
+    eth_signTypedData_v4(domain, types, data) {
+        return this.eth_signTypedData(domain, types, data);
+    }
+    async eth_signTransaction(transaction, provider) {
+        // Populate transaction
+        const preparedTransaction = await this.connect(provider).populateTransaction(transaction);
+        delete preparedTransaction.from;
+        const txObj = Transaction.from(preparedTransaction);
+        return this.wallet.signTransaction(txObj);
+    }
+    eth_sendTransaction(transaction, provider) {
+        return this.connect(provider).sendTransaction(transaction);
+    }
+    eth_sendRawTransaction(rawTransaction, provider) {
+        return provider.broadcastTransaction(rawTransaction);
+    }
+    static init({ privateKey }) {
+        const wallet = privateKey ? new Wallet(privateKey) : Wallet.createRandom();
+        return new EIP155Wallet(wallet);
+    }
+    getPrivateKey() {
+        return this.wallet.privateKey;
+    }
+    getEvmAddress() {
+        return this.wallet.address;
+    }
+    async approveSessionRequest(requestEvent) {
+        const { params, id } = requestEvent;
+        const { chainId, request } = params;
+        const networks = Object.values(HederaChainDefinition.EVM);
+        const caipNetwork = networks.find((network) => network.caipNetworkId == chainId);
+        if (!caipNetwork) {
+            return formatJsonRpcError(id, 'Unsupported network');
+        }
+        switch (request.method) {
+            case Eip155JsonRpcMethod.PersonalSign:
+            case Eip155JsonRpcMethod.Sign:
+                try {
+                    const message = getSignParamsMessage(request.params);
+                    const signedMessage = await this.eth_sign(message);
+                    return formatJsonRpcResult(id, signedMessage);
+                }
+                catch (error) {
+                    if (!(error instanceof Error)) {
+                        return formatJsonRpcError(id, 'Failed to sign message');
+                    }
+                    return formatJsonRpcError(id, error.message);
+                }
+            case Eip155JsonRpcMethod.SignTypedData:
+            case Eip155JsonRpcMethod.SignTypedDataV3:
+            case Eip155JsonRpcMethod.SignTypedDataV4:
+                try {
+                    const { domain, types, message: data } = getSignTypedDataParamsData(request.params);
+                    // https://github.com/ethers-io/ethers.js/issues/687#issuecomment-714069471
+                    delete types.EIP712Domain;
+                    const signedData = await this.eth_signTypedData(domain, types, data);
+                    return formatJsonRpcResult(id, signedData);
+                }
+                catch (error) {
+                    if (!(error instanceof Error)) {
+                        return formatJsonRpcError(id, 'Failed to sign typed data');
+                    }
+                    return formatJsonRpcError(id, error.message);
+                }
+            case Eip155JsonRpcMethod.SendRawTransaction:
+            case Eip155JsonRpcMethod.SendTransaction:
+                try {
+                    const provider = new JsonRpcProvider(caipNetwork.rpcUrls.default.http[0]);
+                    const sendTransaction = request.params[0];
+                    const txResponse = await this[request.method](sendTransaction, provider);
+                    const txHash = typeof txResponse === 'string' ? txResponse : txResponse === null || txResponse === void 0 ? void 0 : txResponse.hash;
+                    return formatJsonRpcResult(id, txHash);
+                }
+                catch (error) {
+                    return formatJsonRpcError(id, error instanceof Error ? error.message : 'Failed to send transaction');
+                }
+            case Eip155JsonRpcMethod.SignTransaction:
+                try {
+                    const provider = new JsonRpcProvider(caipNetwork.rpcUrls.default.http[0]);
+                    const signTransaction = request.params[0];
+                    const signature = await this.eth_signTransaction(signTransaction, provider);
+                    return formatJsonRpcResult(id, signature);
+                }
+                catch (error) {
+                    if (!(error instanceof Error)) {
+                        return formatJsonRpcError(id, 'Failed to sign transaction');
+                    }
+                    return formatJsonRpcError(id, error.message);
+                }
+            default:
+                throw new Error(getSdkError('INVALID_METHOD').message);
+        }
+    }
+    rejectSessionRequest(requestEvent) {
+        const { id } = requestEvent;
+        return formatJsonRpcError(id, getSdkError('USER_REJECTED').message);
+    }
+}

package/dist/reown/wallets/HIP820Wallet.d.ts

@@ -0,0 +1,53 @@
+import { Wallet as HederaWallet, AccountId, Transaction, Query, PrivateKey } from '@hashgraph/sdk';
+import { JsonRpcError, JsonRpcResult } from '@walletconnect/jsonrpc-utils';
+import { HederaChainId, HederaJsonRpcMethod, GetNodeAddressesResult, ExecuteTransactionResult, SignAndExecuteQueryResult, SignMessageResult, SignAndExecuteTransactionResult, SignTransactionResult, WalletRequestEventArgs } from '../..';
+import Provider from '../../lib/wallet/provider';
+interface IInitArgs {
+    chainId: HederaChainId;
+    accountId: AccountId | string;
+    privateKey: PrivateKey;
+    _provider?: Provider;
+}
+export interface HIP820WalletInterface {
+    approveSessionRequest(requestEvent: WalletRequestEventArgs): Promise<JsonRpcResult<any> | JsonRpcError>;
+    rejectSessionRequest(requestEvent: WalletRequestEventArgs): JsonRpcError;
+    getHederaWallet(): HederaWallet;
+    [HederaJsonRpcMethod.GetNodeAddresses](id: number, _: any): Promise<GetNodeAddressesResult>;
+    [HederaJsonRpcMethod.ExecuteTransaction](id: number, body: Transaction): Promise<ExecuteTransactionResult | JsonRpcError>;
+    [HederaJsonRpcMethod.SignMessage](id: number, body: string): Promise<SignMessageResult>;
+    [HederaJsonRpcMethod.SignAndExecuteQuery](id: number, body: Query<any>): Promise<SignAndExecuteQueryResult | JsonRpcError>;
+    [HederaJsonRpcMethod.SignAndExecuteTransaction](id: number, body: Transaction): Promise<SignAndExecuteTransactionResult | JsonRpcError>;
+    [HederaJsonRpcMethod.SignTransaction](id: number, body: Uint8Array): Promise<SignTransactionResult>;
+}
+export declare class HIP820Wallet implements HIP820WalletInterface {
+    wallet: HederaWallet;
+    constructor(wallet: HederaWallet);
+    getHederaWallet(): HederaWallet;
+    static init({ chainId, accountId, privateKey, _provider }: IInitArgs): HIP820Wallet;
+    validateParam(name: string, value: any, expectedType: string): void;
+    parseSessionRequest(event: WalletRequestEventArgs, shouldThrow?: boolean): {
+        method: HederaJsonRpcMethod;
+        chainId: HederaChainId;
+        id: number;
+        topic: string;
+        body?: Transaction | Query<any> | string | Uint8Array | undefined;
+        accountId?: AccountId;
+    };
+    approveSessionRequest(event: WalletRequestEventArgs): Promise<JsonRpcResult<any> | JsonRpcError>;
+    rejectSessionRequest(requestEvent: WalletRequestEventArgs): JsonRpcError;
+    hedera_getNodeAddresses(id: number, _: any): Promise<JsonRpcResult<{
+        nodes: string[];
+    }>>;
+    hedera_executeTransaction(id: number, signedTransaction: Transaction): Promise<ExecuteTransactionResult | JsonRpcError>;
+    hedera_signMessage(id: number, body: string): Promise<JsonRpcResult<{
+        signatureMap: string;
+    }>>;
+    hedera_signAndExecuteQuery(id: number, body: Query<any>): Promise<JsonRpcError | JsonRpcResult<{
+        response: string;
+    }>>;
+    hedera_signAndExecuteTransaction(id: number, transaction: Transaction): Promise<JsonRpcError | JsonRpcResult<import("@hashgraph/sdk/lib/transaction/TransactionResponse").TransactionResponseJSON>>;
+    hedera_signTransaction(id: number, body: Uint8Array): Promise<JsonRpcResult<{
+        signatureMap: string;
+    }>>;
+}
+export default HIP820Wallet;

package/dist/reown/wallets/HIP820Wallet.js

@@ -0,0 +1,236 @@
+import { Buffer } from 'buffer';
+import { getSdkError } from '@walletconnect/utils';
+import { Wallet as HederaWallet, Client, AccountId, PrecheckStatusError, } from '@hashgraph/sdk';
+import { proto } from '@hashgraph/proto';
+import { formatJsonRpcError, formatJsonRpcResult, } from '@walletconnect/jsonrpc-utils';
+import { HederaJsonRpcMethod, base64StringToQuery, Uint8ArrayToBase64String, stringToSignerMessage, signerSignaturesToSignatureMap, getHederaError, base64StringToTransaction, signatureMapToBase64String, } from '../..';
+import Provider from '../../lib/wallet/provider';
+export class HIP820Wallet {
+    /*
+     * Set default values for chains, methods, events
+     */
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    /*
+     * Hedera Wallet Signer
+     */
+    getHederaWallet() {
+        return this.wallet;
+    }
+    static init({ 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);
+        const wallet = new HederaWallet(accountId, privateKey, provider);
+        return new HIP820Wallet(wallet);
+    }
+    /*
+     *  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 approveSessionRequest(event) {
+        const { method, id, body } = this.parseSessionRequest(event);
+        const response = await this[method](id, body);
+        return response;
+    }
+    rejectSessionRequest(requestEvent) {
+        const { id } = requestEvent;
+        return formatJsonRpcError(id, getSdkError('USER_REJECTED').message);
+    }
+    /*
+     * JSON RPC Methods
+     */
+    // 1. hedera_getNodeAddresses
+    async hedera_getNodeAddresses(id, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _) {
+        const nodesAccountIds = this.wallet.getNetwork();
+        const nodes = Object.values(nodesAccountIds).map((nodeAccountId) => nodeAccountId.toString());
+        return formatJsonRpcResult(id, {
+            nodes,
+        });
+    }
+    // 2. hedera_executeTransaction
+    async hedera_executeTransaction(id, signedTransaction) {
+        try {
+            const response = await this.wallet.call(signedTransaction);
+            return formatJsonRpcResult(id, response.toJSON());
+        }
+        catch (e) {
+            if (e instanceof PrecheckStatusError) {
+                // HIP-820 error format
+                return formatJsonRpcError(id, {
+                    code: 9000,
+                    message: e.message,
+                    data: e.status._code.toString(),
+                });
+            }
+            return formatJsonRpcError(id, { code: 9000, message: 'Unknown Error' });
+        }
+    }
+    // 3. hedera_signMessage
+    async hedera_signMessage(id, body) {
+        // signer takes an array of Uint8Arrays though spec allows for 1 message to be signed
+        const signerSignatures = await this.wallet.sign(stringToSignerMessage(body));
+        const _signatureMap = proto.SignatureMap.create(signerSignaturesToSignatureMap(signerSignatures));
+        const signatureMap = signatureMapToBase64String(_signatureMap);
+        return formatJsonRpcResult(id, {
+            signatureMap,
+        });
+    }
+    // 4. hedera_signAndExecuteQuery
+    async hedera_signAndExecuteQuery(id, body) {
+        /*
+         * 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
+         */
+        try {
+            const queryResult = await body.executeWithSigner(this.wallet);
+            let queryResponse = '';
+            if (Array.isArray(queryResult)) {
+                queryResponse = queryResult
+                    .map((qr) => Uint8ArrayToBase64String(qr.toBytes()))
+                    .join(',');
+            }
+            else {
+                queryResponse = Uint8ArrayToBase64String(queryResult.toBytes());
+            }
+            return formatJsonRpcResult(id, {
+                response: queryResponse,
+            });
+        }
+        catch (e) {
+            if (e instanceof PrecheckStatusError) {
+                // HIP-820 error format
+                return formatJsonRpcError(id, {
+                    code: 9000,
+                    message: e.message,
+                    data: e.status._code.toString(),
+                });
+            }
+            return formatJsonRpcError(id, { code: 9000, message: 'Unknown Error' });
+        }
+    }
+    // 5. hedera_signAndExecuteTransaction
+    async hedera_signAndExecuteTransaction(id, transaction) {
+        // check transaction is incomplete (HIP-745)
+        if (!transaction.isFrozen()) {
+            // set multiple nodeAccountIds and transactionId if not present
+            await transaction.freezeWithSigner(this.wallet);
+        }
+        const signedTransaction = await transaction.signWithSigner(this.wallet);
+        try {
+            const response = await signedTransaction.executeWithSigner(this.wallet);
+            return formatJsonRpcResult(id, response.toJSON());
+        }
+        catch (e) {
+            if (e instanceof PrecheckStatusError) {
+                // HIP-820 error format
+                return formatJsonRpcError(id, {
+                    code: 9000,
+                    message: e.message,
+                    data: e.status._code.toString(),
+                });
+            }
+            return formatJsonRpcError(id, { code: 9000, message: 'Unknown Error' });
+        }
+    }
+    // 6. hedera_signTransaction
+    async hedera_signTransaction(id, body) {
+        const signerSignatures = await this.wallet.sign([body]);
+        const _signatureMap = proto.SignatureMap.create(signerSignaturesToSignatureMap(signerSignatures));
+        const signatureMap = signatureMapToBase64String(_signatureMap);
+        return formatJsonRpcResult(id, {
+            signatureMap,
+        });
+    }
+}
+export default HIP820Wallet;

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

@@ -0,0 +1,2 @@
+export * from './EIP155Wallet';
+export * from './HIP820Wallet';

package/dist/reown/wallets/index.js

@@ -0,0 +1,2 @@
+export * from './EIP155Wallet';
+export * from './HIP820Wallet';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "2.0.1-canary.7e04cff.0",
+  "version": "2.0.1-canary.8bde0e3.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
@@ -14,9 +14,11 @@
     "walletconnect",
     "reown",
     "hashgraph",
-    "hbar",
     "evm",
-    "smart contracts"
+    "ethereum",
+    "smart contracts",
+    "hbar",
+    "ethers"
   ],
   "license": "Apache-2.0",
   "scripts": {