@hinkal/common 0.0.117 → 0.0.118

package/providers/Wagmi1ProviderAdapter.d.ts

@@ -0,0 +1,41 @@
+import { TransactionRequest } from '@ethersproject/providers';
+import { ChainEventListener, ContractMetadata, ContractType, EthereumNetwork, IProviderAdapter } from '../index';
+import { ethers } from 'ethers';
+import { Connector } from 'wagmi';
+import { type WalletClient } from '@wagmi/core';
+export declare class ProviderAdapter implements IProviderAdapter {
+    private connector;
+    chainId: number | undefined;
+    private originalProvider;
+    private fetchProvider;
+    private signer;
+    private chainEventListener?;
+    private unsubscribeFns;
+    constructor(connector: Connector);
+    init(chainId?: number): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    connectToConnector(connector: Connector): Promise<number>;
+    waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    getSelectedNetwork: () => EthereumNetwork | undefined;
+    switchNetwork(network: EthereumNetwork): Promise<import("@wagmi/core").SwitchNetworkResult>;
+    private createFetchProvider;
+    getAddress(): Promise<string>;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    release(): void;
+    private removeListeners;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contractType: ContractType, contractAddress?: undefined, chainId?: number): ethers.Contract;
+    getContractWithSigner(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    sendTransaction(tx: TransactionRequest): Promise<ethers.providers.TransactionResponse>;
+    patchExternalProvider(connector: Connector): Promise<void>;
+    connectAndPatchProvider(connector: Connector): Promise<number>;
+    isPermitterAvailable(): boolean;
+    getGasPrice(): Promise<bigint>;
+    walletClientToSigner(walletClient: WalletClient, chainId: number): Promise<ethers.providers.JsonRpcSigner>;
+}

package/providers/Wagmi1ProviderAdapter.mjs

@@ -0,0 +1,210 @@
+import { networkRegistry as s, chainIds as c, localhostNetwork as w } from "../constants/chains.constants.mjs";
+import "../types/circom-data.types.mjs";
+import "../types/transactions.types.mjs";
+import "../types/curve.types.mjs";
+import { transactionErrorCodes as o } from "../error-handling/error-codes.constants.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/circomlibjs/node_modules/ffjavascript/build/browser.esm.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/blake2b/index.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/blake-hash/lib/api/blake.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/blake-hash/lib/blake224.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/blake-hash/lib/blake256.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/blake-hash/lib/blake384.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/blake-hash/lib/blake512.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/circomlibjs/src/poseidon_gencontract.mjs";
+import "../_virtual/assert.mjs";
+import "../data-structures/crypto-keys/keys.mjs";
+import "../data-structures/crypto-keys/encryptDecryptUtxo.mjs";
+import "../data-structures/custom-token-registry/CustomTokenRegistry.mjs";
+import "../functions/utils/external-action.utils.mjs";
+import "../functions/utils/convertIntegrationProviderToExternalActionId.mjs";
+import "../functions/utils/userAgent.mjs";
+import "../data-structures/volatile-helper/VolatileHelper.mjs";
+import "../webworker/workerFactory.mjs";
+import "../constants/reorg-depths.constants.mjs";
+import "../constants/kyc.constants.mjs";
+import "../constants/coingecko.constants.mjs";
+import "../constants/vite.constants.mjs";
+import "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.mjs";
+import { contractMetadataMapping as p } from "../constants/contracts.constants.mjs";
+import "../constants/axelar.constants.mjs";
+import "../constants/rewards.constants.mjs";
+import { disconnect as l, getAccount as a, connect as g, signMessage as u, switchNetwork as f, watchAccount as m, watchNetwork as v } from "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@wagmi/core/dist/chunk-TSH6VVF4.mjs";
+import { WebSocketProvider as E } from "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/providers/lib.esm/websocket-provider.mjs";
+import { StaticJsonRpcProvider as h } from "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/providers/lib.esm/url-json-rpc-provider.mjs";
+import { getAddress as C } from "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/address/lib.esm/index.mjs";
+import { Contract as P } from "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/contracts/lib.esm/index.mjs";
+import { Web3Provider as d } from "../Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/providers/lib.esm/web3-provider.mjs";
+class ct {
+  connector;
+  chainId;
+  originalProvider;
+  fetchProvider;
+  signer;
+  chainEventListener;
+  unsubscribeFns = [];
+  constructor(t) {
+    this.connector = t;
+  }
+  async init(t) {
+    t && (this.chainId = t), this.originalProvider = await this.connector.getProvider(), this.fetchProvider = this.createFetchProvider() ?? this.originalProvider, this.fetchProvider === this.originalProvider && console.warn("fetchProvider not available");
+    const r = await this.connector.getWalletClient();
+    this.signer = await this.walletClientToSigner(r, this.chainId);
+  }
+  async disconnectFromConnector() {
+    this.release(), await l();
+  }
+  async connectToConnector(t) {
+    const { isConnected: r } = a();
+    r && await this.disconnectFromConnector();
+    try {
+      return (await g({ connector: t })).chain.id;
+    } catch {
+      throw new Error(o.CONNECTION_FAILED);
+    }
+  }
+  async waitForTransaction(t, r) {
+    if ((await this.fetchProvider?.waitForTransaction(t, r))?.status)
+      return !0;
+    throw Error(o.TRANSACTION_NOT_CONFIRMED);
+  }
+  async signMessage(t) {
+    const r = await u({ message: t });
+    if (!r)
+      throw new Error(o.SIGNING_FAILED);
+    if (r.includes("error"))
+      throw new Error(o.SIGNATURE_UNSUPPORTED_PERSONAL_SIGN);
+    return r;
+  }
+  async signTypedData(t, r, e) {
+    return this.signer._signTypedData(t, r, e);
+  }
+  getSelectedNetwork = () => {
+    if (!this.chainId)
+      throw new Error("Illegal state: no chaindId");
+    return s[this.chainId];
+  };
+  async switchNetwork(t) {
+    return f({ chainId: t.chainId });
+  }
+  createFetchProvider() {
+    try {
+      const r = s[this.chainId]?.fetchRpcUrl;
+      return r ? r.includes("wss") ? new E(r) : new h(r) : void 0;
+    } catch (t) {
+      console.log("create Fetch Provider error", t);
+      return;
+    }
+  }
+  async getAddress() {
+    const { address: t } = a();
+    if (!t)
+      throw new Error("IllegalState");
+    return C(t);
+  }
+  setChainEventListener(t) {
+    this.chainEventListener = t, this.chainEventListener && (this.unsubscribeFns.push(
+      m((r) => {
+        if (!this.chainEventListener) {
+          console.warn("chainEventListener is not set");
+          return;
+        }
+        this.chainEventListener.onAccountChanged();
+      })
+    ), this.unsubscribeFns.push(
+      v((r) => {
+        if (!this.chainEventListener) {
+          console.warn("chainEventListener is not set");
+          return;
+        }
+        this.chainEventListener.onChainChanged(r.chain?.id);
+      })
+    ));
+  }
+  onAccountChanged() {
+    return this.init();
+  }
+  onChainChanged(t) {
+    return this.init(t);
+  }
+  release() {
+    this.removeListeners();
+  }
+  removeListeners() {
+    this.unsubscribeFns.forEach((t) => t()), this.unsubscribeFns = [];
+  }
+  getContractMetadata(t, r) {
+    const e = r ?? this.chainId;
+    if (!e)
+      throw new Error("No chainId provided in context");
+    const n = s[e];
+    if (!n)
+      throw new Error(o.UNSUPPORTED_NETWORK);
+    const i = p[t];
+    if (!i)
+      throw new Error(`Unsupported contractType: ${t}`);
+    return i(n.contractData);
+  }
+  getContract(t, r = void 0, e) {
+    const n = this.getContractMetadata(t, e);
+    if (!n.abi)
+      throw new Error(`No ABI configured for contractType: ${t}`);
+    if (n.address && r)
+      throw new Error(`Overriding address is not supported for contractType: ${t}`);
+    const i = n.address ?? r;
+    if (!i)
+      throw new Error(`No contractAddress configured for contractType: ${t}`);
+    return new P(i, n.abi);
+  }
+  getContractWithSigner(t, r = void 0) {
+    if (!this.signer)
+      throw new Error("IllegalState: no signer");
+    return this.getContract(t, r).connect(this.signer);
+  }
+  getContractWithFetcher(t, r = void 0) {
+    if (!this.fetchProvider)
+      throw new Error("fetchProvider not initialized");
+    return this.getContract(t, r).connect(this.fetchProvider);
+  }
+  getContractWithFetcherForEthereum(t, r = void 0) {
+    const e = this.chainId === c.localhost && w === c.ethMainnet ? c.localhost : c.ethMainnet;
+    return this.getContract(t, r).connect(
+      new h(s[e].fetchRpcUrl)
+    );
+  }
+  async sendTransaction(t) {
+    if (!this.signer)
+      throw new Error("IllegalState: no signer");
+    return await this.signer.sendTransaction(t);
+  }
+  async patchExternalProvider(t) {
+    const r = await t.getProvider();
+    let e;
+    if (r instanceof d ? e = r.provider : e = r, "isWalletConnect" in e) {
+      const n = await t.getChainId();
+      e.http = e.setHttpProvider?.(n);
+    }
+  }
+  async connectAndPatchProvider(t) {
+    const r = await this.connectToConnector(t);
+    return await this.patchExternalProvider(t), r;
+  }
+  isPermitterAvailable() {
+    return !!this.getSelectedNetwork()?.contractData?.permitterAddress;
+  }
+  async getGasPrice() {
+    const t = await this.fetchProvider?.getGasPrice();
+    if (!t)
+      throw Error("Could not fetch gas price in getGasPrice");
+    return t.toBigInt();
+  }
+  async walletClientToSigner(t, r) {
+    const { account: e, transport: n } = t, i = {
+      chainId: r,
+      name: ""
+    };
+    return new d(n, i).getSigner(e.address);
+  }
+}
+export {
+  ct as ProviderAdapter
+};