@cityofzion/bs-ethereum 2.13.5 → 2.14.0

package/dist/BSEthereum.d.ts

@@ -1,7 +1,8 @@
-import { TBSAccount, TBSToken, TTransferParam, TGetLedgerTransport, ITokenService, TBSNetwork, IBlockchainDataService, IExchangeDataService, INftDataService, IExplorerService, TPingNetworkResponse } from '@cityofzion/blockchain-service';
+import { TBSAccount, TBSToken, TTransferParam, TGetLedgerTransport, ITokenService, TBSNetwork, IBlockchainDataService, IExchangeDataService, INftDataService, IExplorerService, TPingNetworkResponse, IWalletConnectService } from '@cityofzion/blockchain-service';
 import { ethers } from 'ethers';
 import { EthersLedgerServiceEthereum } from './services/ledger/EthersLedgerServiceEthereum';
 import { IBSEthereum, TBSEthereumNetworkId, TSupportedEVM } from './types';
+import { TypedDataSigner } from '@ethersproject/abstract-signer';
 export declare class BSEthereum<N extends string = string, A extends string = TBSEthereumNetworkId> implements IBSEthereum<N, A> {
     #private;
     readonly name: N;
@@ -21,8 +22,9 @@ export declare class BSEthereum<N extends string = string, A extends string = TB
     nftDataService: INftDataService;
     explorerService: IExplorerService;
     tokenService: ITokenService;
+    walletConnectService: IWalletConnectService;
     constructor(name: N, evm?: TSupportedEVM, network?: TBSNetwork<A>, getLedgerTransport?: TGetLedgerTransport<N>);
-    generateSigner(account: TBSAccount<N>): Promise<ethers.Signer>;
+    generateSigner(account: TBSAccount<N>): Promise<ethers.Signer & TypedDataSigner>;
     setNetwork(network: TBSNetwork<A>): void;
     pingNetwork(network: TBSNetwork<A>): Promise<TPingNetworkResponse>;
     validateAddress(address: string): boolean;

package/dist/BSEthereum.js

@@ -65,6 +65,7 @@ const MoralisEDSEthereum_1 = require("./services/exchange-data/MoralisEDSEthereu
 const GhostMarketNDSEthereum_1 = require("./services/nft-data/GhostMarketNDSEthereum");
 const BlockscoutESEthereum_1 = require("./services/explorer/BlockscoutESEthereum");
 const TokenServiceEthereum_1 = require("./services/token/TokenServiceEthereum");
+const WalletConnectServiceEthereum_1 = require("./services/wallet-connect/WalletConnectServiceEthereum");
 const axios_1 = __importDefault(require("axios"));
 class BSEthereum {
     constructor(name, evm, network, getLedgerTransport) {
@@ -108,6 +109,7 @@ class BSEthereum {
         this.exchangeDataService = new MoralisEDSEthereum_1.MoralisEDSEthereum(this);
         this.blockchainDataService = new MoralisBDSEthereum_1.MoralisBDSEthereum(this);
         this.tokenService = new TokenServiceEthereum_1.TokenServiceEthereum();
+        this.walletConnectService = new WalletConnectServiceEthereum_1.WalletConnectServiceEthereum(this);
     }
     // This method is done manually because we need to ensure that the request is aborted after timeout
     pingNetwork(network) {

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from './services/explorer/BlockscoutESEthereum';
 export * from './services/ledger/EthersLedgerServiceEthereum';
 export * from './services/nft-data/GhostMarketNDSEthereum';
 export * from './services/token/TokenServiceEthereum';
+export * from './services/wallet-connect/WalletConnectServiceEthereum';
 export * from './assets/abis/ERC20';
 export * from './assets/abis/ERC721';
 export * from './types';

package/dist/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./services/explorer/BlockscoutESEthereum"), exports);
 __exportStar(require("./services/ledger/EthersLedgerServiceEthereum"), exports);
 __exportStar(require("./services/nft-data/GhostMarketNDSEthereum"), exports);
 __exportStar(require("./services/token/TokenServiceEthereum"), exports);
+__exportStar(require("./services/wallet-connect/WalletConnectServiceEthereum"), exports);
 __exportStar(require("./assets/abis/ERC20"), exports);
 __exportStar(require("./assets/abis/ERC721"), exports);
 __exportStar(require("./types"), exports);

package/dist/services/wallet-connect/WalletConnectServiceEthereum.d.ts

@@ -0,0 +1,29 @@
+import { IWalletConnectService, TBSNetworkId, TWalletConnectServiceRequestMethodParams } from '@cityofzion/blockchain-service';
+import { IBSEthereum } from '../../types';
+export declare class WalletConnectServiceEthereum<N extends string, A extends TBSNetworkId> implements IWalletConnectService {
+    #private;
+    readonly namespace: string;
+    readonly chain: string;
+    readonly supportedMethods: string[];
+    readonly supportedEvents: string[];
+    readonly calculableMethods: string[];
+    readonly autoApproveMethods: string[];
+    constructor(service: IBSEthereum<N, A>);
+    personal_sign(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_sign(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_signTransaction(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_signTypedData(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_signTypedData_v3(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_signTypedData_v4(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_sendTransaction(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_call(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    eth_requestAccounts(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string[]>;
+    eth_sendRawTransaction(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+    wallet_switchEthereumChain(): Promise<string>;
+    eth_addEthereumChain(): Promise<string>;
+    eth_switchEthereumChain(): Promise<string>;
+    wallet_getPermissions(): Promise<any[]>;
+    wallet_requestPermissions(): Promise<any[]>;
+    wallet_addEthereumChain(): Promise<string>;
+    calculateRequestFee(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
+}

package/dist/services/wallet-connect/WalletConnectServiceEthereum.js

@@ -0,0 +1,220 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WalletConnectServiceEthereum_instances, _WalletConnectServiceEthereum_service, _WalletConnectServiceEthereum_resolveParams, _WalletConnectServiceEthereum_convertHexToUtf8;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletConnectServiceEthereum = void 0;
+const ethers_1 = require("ethers");
+const BSEthereumConstants_1 = require("../../constants/BSEthereumConstants");
+class WalletConnectServiceEthereum {
+    constructor(service) {
+        _WalletConnectServiceEthereum_instances.add(this);
+        this.namespace = 'eip155';
+        this.supportedMethods = [
+            'personal_sign',
+            'eth_sign',
+            'eth_signTransaction',
+            'eth_signTypedData',
+            'eth_signTypedData_v3',
+            'eth_signTypedData_v4',
+            'eth_sendTransaction',
+            'eth_call',
+            'eth_requestAccounts',
+            'eth_sendRawTransaction',
+            'eth_addEthereumChain',
+            'eth_switchEthereumChain',
+            'wallet_switchEthereumChain',
+            'wallet_getPermissions',
+            'wallet_requestPermissions',
+            'wallet_addEthereumChain',
+        ];
+        this.supportedEvents = ['chainChanged', 'accountsChanged', 'disconnect', 'connect'];
+        this.calculableMethods = ['eth_sendTransaction', 'eth_call', 'eth_sendRawTransaction'];
+        this.autoApproveMethods = [
+            'eth_requestAccounts',
+            'eth_addEthereumChain',
+            'eth_switchEthereumChain',
+            'wallet_switchEthereumChain',
+            'wallet_getPermissions',
+            'wallet_requestPermissions',
+            'wallet_addEthereumChain',
+        ];
+        _WalletConnectServiceEthereum_service.set(this, void 0);
+        __classPrivateFieldSet(this, _WalletConnectServiceEthereum_service, service, "f");
+        this.chain = `${this.namespace}:${__classPrivateFieldGet(this, _WalletConnectServiceEthereum_service, "f").network.id.toString()}`;
+    }
+    personal_sign(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_service, "f").generateSigner(args.account);
+            const message = args.params.filter((param) => !ethers_1.ethers.utils.isAddress(param))[0];
+            const convertedMessage = __classPrivateFieldGet(this, _WalletConnectServiceEthereum_instances, "m", _WalletConnectServiceEthereum_convertHexToUtf8).call(this, message);
+            const signedMessage = yield wallet.signMessage(convertedMessage);
+            return signedMessage;
+        });
+    }
+    eth_sign(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.personal_sign(args);
+        });
+    }
+    eth_signTransaction(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { param, wallet } = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_instances, "m", _WalletConnectServiceEthereum_resolveParams).call(this, args);
+            const signature = yield wallet.signTransaction(param);
+            return signature;
+        });
+    }
+    eth_signTypedData(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_service, "f").generateSigner(args.account);
+            const data = args.params.filter((param) => !ethers_1.ethers.utils.isAddress(param))[0];
+            const parsedData = typeof data === 'string' ? JSON.parse(data) : data;
+            const { domain, types, message } = parsedData;
+            // https://github.com/ethers-io/ethers.js/issues/687#issuecomment-714069471
+            delete types.EIP712Domain;
+            const signedData = yield wallet._signTypedData(domain, types, message);
+            return signedData;
+        });
+    }
+    eth_signTypedData_v3(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.eth_signTypedData(args);
+        });
+    }
+    eth_signTypedData_v4(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.eth_signTypedData(args);
+        });
+    }
+    eth_sendTransaction(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { param, provider, wallet } = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_instances, "m", _WalletConnectServiceEthereum_resolveParams).call(this, args);
+            const connectedWallet = wallet.connect(provider);
+            const { hash } = yield connectedWallet.sendTransaction(param);
+            return hash;
+        });
+    }
+    eth_call(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { param, provider, wallet } = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_instances, "m", _WalletConnectServiceEthereum_resolveParams).call(this, args);
+            const connectedWallet = wallet.connect(provider);
+            return yield connectedWallet.call(param);
+        });
+    }
+    eth_requestAccounts(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_service, "f").generateSigner(args.account);
+            return [yield wallet.getAddress()];
+        });
+    }
+    eth_sendRawTransaction(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _WalletConnectServiceEthereum_service, "f").network.url);
+            const { hash } = yield provider.sendTransaction(args.params[0]);
+            return hash;
+        });
+    }
+    wallet_switchEthereumChain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'null';
+        });
+    }
+    eth_addEthereumChain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'null';
+        });
+    }
+    eth_switchEthereumChain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'null';
+        });
+    }
+    wallet_getPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    wallet_requestPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    wallet_addEthereumChain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'null';
+        });
+    }
+    calculateRequestFee(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { param, wallet, provider } = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_instances, "m", _WalletConnectServiceEthereum_resolveParams).call(this, args);
+            const connectedWallet = wallet.connect(provider);
+            const gasPrice = yield provider.getGasPrice();
+            const estimated = yield connectedWallet.estimateGas(param);
+            return ethers_1.ethers.utils.formatEther(gasPrice.mul(estimated));
+        });
+    }
+}
+exports.WalletConnectServiceEthereum = WalletConnectServiceEthereum;
+_WalletConnectServiceEthereum_service = new WeakMap(), _WalletConnectServiceEthereum_instances = new WeakSet(), _WalletConnectServiceEthereum_resolveParams = function _WalletConnectServiceEthereum_resolveParams(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const wallet = yield __classPrivateFieldGet(this, _WalletConnectServiceEthereum_service, "f").generateSigner(args.account);
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(__classPrivateFieldGet(this, _WalletConnectServiceEthereum_service, "f").network.url);
+        const param = args.params[0];
+        if (typeof param !== 'object') {
+            throw new Error('Invalid Params');
+        }
+        if (param.gas) {
+            param.gasLimit = param.gas;
+            delete param.gas;
+        }
+        if (param.type && typeof param.type !== 'number') {
+            param.type = parseInt(param.type);
+        }
+        const gasPrice = yield provider.getGasPrice();
+        if (param.type === 2) {
+            param.maxPriorityFeePerGas = (_a = param.maxPriorityFeePerGas) !== null && _a !== void 0 ? _a : gasPrice;
+            param.maxFeePerGas = (_b = param.maxPriorityFeePerGas) !== null && _b !== void 0 ? _b : gasPrice;
+        }
+        else {
+            param.gasPrice = (_c = param.gasPrice) !== null && _c !== void 0 ? _c : gasPrice;
+        }
+        if (!param.gasLimit) {
+            const connectedWallet = wallet.connect(provider);
+            try {
+                param.gasLimit = yield connectedWallet.estimateGas(Object.assign(Object.assign({}, param), { gasLimit: BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT }));
+            }
+            catch (_d) {
+                param.gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
+            }
+        }
+        return {
+            param,
+            provider,
+            wallet,
+        };
+    });
+}, _WalletConnectServiceEthereum_convertHexToUtf8 = function _WalletConnectServiceEthereum_convertHexToUtf8(value) {
+    if (ethers_1.ethers.utils.isHexString(value)) {
+        return ethers_1.ethers.utils.toUtf8String(value);
+    }
+    return value;
+};

package/dist/types.d.ts

@@ -1,7 +1,10 @@
-import { IBlockchainService, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNft, TBSNetworkId } from '@cityofzion/blockchain-service';
+import { IBlockchainService, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNft, IBSWithWalletConnect, TBSAccount, TBSNetworkId } from '@cityofzion/blockchain-service';
+import { TypedDataSigner } from '@ethersproject/abstract-signer';
+import { ethers } from 'ethers';
 export type TBSEthereumNetworkId = TBSNetworkId<'1' | '10' | '25' | '56' | '137' | '250' | '1101' | '8453' | '80002' | '42161' | '42220' | '43114' | '59144' | '11155111'>;
 export type TSupportedEVM = 'ethereum' | 'polygon' | 'base' | 'arbitrum';
-export interface IBSEthereum<N extends string = string, A extends string = TBSEthereumNetworkId> extends IBlockchainService<N, A>, IBSWithNft, IBSWithNameService, IBSWithFee<N>, IBSWithLedger<N>, IBSWithExplorer, IBSWithEncryption<N> {
+export interface IBSEthereum<N extends string = string, A extends string = TBSEthereumNetworkId> extends IBlockchainService<N, A>, IBSWithNft, IBSWithNameService, IBSWithFee<N>, IBSWithLedger<N>, IBSWithExplorer, IBSWithEncryption<N>, IBSWithWalletConnect {
+    generateSigner(account: TBSAccount<N>): Promise<ethers.Signer & TypedDataSigner>;
 }
 export type TMoralisBDSEthereumNativeBalanceApiResponse = {
     balance: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-ethereum",
-  "version": "2.13.5",
+  "version": "2.14.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -19,7 +19,7 @@
     "@ethersproject/abstract-signer": "5.7.0",
     "@ethersproject/properties": "5.7.0",
     "@cityofzion/dora-ts": "~0.5.1",
-    "@cityofzion/blockchain-service": "1.21.3"
+    "@cityofzion/blockchain-service": "1.22.0"
   },
   "devDependencies": {
     "@ledgerhq/hw-transport": "~6.31.11",