@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/balances/providers/tonBalanceProvider.js

@@ -1,104 +1,78 @@
-// import { datadogRum } from "@datadog/browser-rum";
-// import { Balance } from "../../../Models/Balance";
-// import { Network, NetworkWithTokens, Token } from "../../../Models/Network";
-// import formatAmount from "../../formatAmount";
-// import KnownInternalNames from "../../knownIds";
-// import retryWithExponentialBackoff from "../../retry";
-// import tonClient from "../../wallets/ton/client";
-// import { insertIfNotExists } from "./helpers";
-// export class TonBalanceProvider {
-//     supportsNetwork(network: NetworkWithTokens): boolean {
-//         return KnownInternalNames.Networks.TONMainnet.includes(network.name)
-//     }
-//     fetchBalance = async (address: string, network: NetworkWithTokens) => {
-//         let balances: Balance[] = []
-//         const tokens = insertIfNotExists(network.tokens || [], network.token)
-//         for (const token of tokens) {
-//             try {
-//                 const balance = await resolveBalance({ network, address, token })
-//                 if (!balance) return
-//                 balances = [
-//                     ...balances,
-//                     balance,
-//                 ]
-//             }
-//             catch (e) {
-//                 console.log(e)
-//             }
-//         }
-//         return balances
-//     }
-// }
-// export const resolveBalance = async ({ address, network, token }: {
-//     network: Network,
-//     token: Token,
-//     address: string
-// }
-// ) => {
-//     if (token.contract) {
-//         const res = await getJettonBalance({ network, token, address })
-//         return res
-//     }
-//     else {
-//         const res = await getNativeAssetBalance({ network, token, address })
-//         return res
-//     }
-// }
-// const getNativeAssetBalance = async ({ network, token, address }: { network: Network, token: Token, address: string }) => {
-//     try {
-//         const { Address } = await import("@ton/ton");
-//         const getBalance = async () => {
-//             return await tonClient.getBalance(Address.parse(address))
-//         }
-//         const tonBalance = await retryWithExponentialBackoff(getBalance)
-//         return ({
-//             network: network.name,
-//             token: token.symbol,
-//             amount: formatAmount(tonBalance.toString(), Number(token?.decimals)),
-//             request_time: new Date().toJSON(),
-//             decimals: Number(token?.decimals),
-//             isNativeCurrency: false,
-//         })
-//     }
-//     catch (e) {
-//         const error = new Error(e)
-//         error.name = "TonNativeAssetBalanceError"
-//         error.cause = e
-//         datadogRum.addError(error);
-//         return null;
-//     }
-// }
-// const getJettonBalance = async ({ network, token, address }: { network: Network, token: Token, address: string }) => {
-//     try {
-//         const { JettonMaster, JettonWallet, Address } = await import("@ton/ton");
-//         const jettonMasterAddress = Address.parse(token.contract!)
-//         const userAddress = Address.parse(address)
-//         const jettonMaster = tonClient.open(JettonMaster.create(jettonMasterAddress))
-//         const getJettonAddress = async () => {
-//             return await jettonMaster.getWalletAddress(userAddress)
-//         }
-//         const jettonAddress = await retryWithExponentialBackoff(getJettonAddress)
-//         await new Promise((resolve) => setTimeout(resolve, 1000))
-//         const jettonWallet = JettonWallet.create(jettonAddress)
-//         const getBalance = async () => {
-//             return await jettonWallet.getBalance(tonClient.provider(jettonAddress))
-//         }
-//         const jettonBalance = await retryWithExponentialBackoff(getBalance)
-//         const balance = {
-//             network: network.name,
-//             token: token.symbol,
-//             amount: formatAmount(Number(BigInt(jettonBalance)), token.decimals),
-//             request_time: new Date().toJSON(),
-//             decimals: token.decimals,
-//             isNativeCurrency: false,
-//         }
-//         return balance
-//     }
-//     catch (e) {
-//         const error = new Error(e)
-//         error.name = "TonJettonBalanceError"
-//         error.cause = e
-//         datadogRum.addError(error);
-//         return null;
-//     }
-// }
+import formatAmount from "../../../lib/formatAmount";
+import KnownInternalNames from "../../../lib/knownIds";
+import retryWithExponentialBackoff from "../../../lib/retry";
+import tonClient from "../../../lib/wallets/ton/client";
+import { insertIfNotExists } from "../helpers";
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export class TonBalanceProvider extends BalanceProvider {
+    constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return KnownInternalNames.Networks.TONMainnet.includes(network.name);
+        };
+        this.fetchBalance = async (address, network) => {
+            let balances = [];
+            const tokens = insertIfNotExists(network.tokens || [], network.token);
+            for (const token of tokens) {
+                try {
+                    const balance = await resolveBalance({ network, address, token });
+                    balances.push(balance);
+                }
+                catch (e) {
+                    balances.push(this.resolveTokenBalanceFetchError(e, token, network));
+                }
+            }
+            return balances;
+        };
+    }
+}
+export const resolveBalance = async ({ address, network, token }) => {
+    if (token.contract) {
+        const res = await getJettonBalance({ network, token, address });
+        return res;
+    }
+    else {
+        const res = await getNativeAssetBalance({ network, token, address });
+        return res;
+    }
+};
+const getNativeAssetBalance = async ({ network, token, address }) => {
+    const { Address } = await import("@ton/ton");
+    const getBalance = async () => {
+        return await tonClient.getBalance(Address.parse(address));
+    };
+    const tonBalance = await retryWithExponentialBackoff(getBalance);
+    return ({
+        network: network.name,
+        token: token.symbol,
+        amount: formatAmount(tonBalance.toString(), Number(token?.decimals)),
+        request_time: new Date().toJSON(),
+        decimals: Number(token?.decimals),
+        isNativeCurrency: true,
+    });
+};
+const getJettonBalance = async ({ network, token, address }) => {
+    const { JettonMaster, JettonWallet, Address } = await import("@ton/ton");
+    const jettonMasterAddress = Address.parse(token.contract);
+    const userAddress = Address.parse(address);
+    const jettonMaster = tonClient.open(JettonMaster.create(jettonMasterAddress));
+    const getJettonAddress = async () => {
+        return await jettonMaster.getWalletAddress(userAddress);
+    };
+    const jettonAddress = await retryWithExponentialBackoff(getJettonAddress);
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const jettonWallet = JettonWallet.create(jettonAddress);
+    const getBalance = async () => {
+        return await jettonWallet.getBalance(tonClient.provider(jettonAddress));
+    };
+    const jettonBalance = await retryWithExponentialBackoff(getBalance);
+    const balance = {
+        network: network.name,
+        token: token.symbol,
+        amount: formatAmount(Number(BigInt(jettonBalance)), token.decimals),
+        request_time: new Date().toJSON(),
+        decimals: token.decimals,
+        isNativeCurrency: false,
+    };
+    return balance;
+};

package/dist/lib/balances/providers/{tronBalanceResolver.d.ts → tronBalanceProvider.d.ts}

@@ -1,9 +1,10 @@
-import { Balance } from "../../../Models/Balance";
+import { TokenBalance } from "../../../Models/Balance";
 import { Network, NetworkWithTokens, Token } from "../../../Models/Network";
 import { TronWeb } from 'tronweb';
-export declare class TronBalanceProvider {
-    supportsNetwork(network: NetworkWithTokens): boolean;
-    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<Balance[] | undefined>;
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export declare class TronBalanceProvider extends BalanceProvider {
+    supportsNetwork: (network: NetworkWithTokens) => boolean;
+    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<TokenBalance[]>;
 }
 type GetBalanceProps = {
     network: Network;
@@ -18,5 +19,5 @@ export declare const resolveBalance: ({ address, network, token, provider }: Get
     request_time: string;
     decimals: number;
     isNativeCurrency: boolean;
-} | null>;
+}>;
 export {};

package/dist/lib/balances/providers/tronBalanceProvider.js

@@ -0,0 +1,65 @@
+import formatAmount from "../../formatAmount";
+import KnownInternalNames from "../../knownIds";
+import { TronWeb } from 'tronweb';
+import { insertIfNotExists } from "../helpers";
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export class TronBalanceProvider extends BalanceProvider {
+    constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return KnownInternalNames.Networks.TronMainnet.includes(network.name);
+        };
+        this.fetchBalance = async (address, network) => {
+            let balances = [];
+            const provider = new TronWeb({ fullNode: network.node_url, solidityNode: network.node_url, privateKey: '01' });
+            const tokens = insertIfNotExists(network.tokens, network.token);
+            for (const token of tokens) {
+                try {
+                    const balance = await resolveBalance({ network, address, token, provider });
+                    balances.push(balance);
+                }
+                catch (e) {
+                    balances.push(this.resolveTokenBalanceFetchError(e, token, network));
+                }
+            }
+            return balances;
+        };
+    }
+}
+export const resolveBalance = async ({ address, network, token, provider }) => {
+    if (token.contract) {
+        const res = await getTRC20Balance({ network, token, address, provider });
+        return res;
+    }
+    else {
+        const res = await getNativeAssetBalance({ network, token, address, provider });
+        return res;
+    }
+};
+const getNativeAssetBalance = async ({ network, token, address, provider }) => {
+    const balance = await provider.trx.getBalance(address);
+    return ({
+        network: network.name,
+        token: token.symbol,
+        amount: formatAmount(balance.toString(), Number(token?.decimals)),
+        request_time: new Date().toJSON(),
+        decimals: Number(token?.decimals),
+        isNativeCurrency: true,
+    });
+};
+const getTRC20Balance = async ({ network, token, address, provider }) => {
+    if (!token.contract)
+        throw new Error("Token contract address is missing");
+    const tokenContractAddress = token.contract;
+    const contract = await provider.contract().at(tokenContractAddress);
+    const balanceResponse = await contract.methods.balanceOf(address).call();
+    const balance = {
+        network: network.name,
+        token: token.symbol,
+        amount: formatAmount(BigInt(balanceResponse), token.decimals),
+        request_time: new Date().toJSON(),
+        decimals: token.decimals,
+        isNativeCurrency: false,
+    };
+    return balance;
+};

package/dist/lib/balances/providers/zkSyncBalanceProvider.d.ts

@@ -1,7 +1,7 @@
 import { NetworkWithTokens } from "../../../Models/Network";
-export declare class ZkSyncBalanceProvider {
-    supportsNetwork(network: NetworkWithTokens): boolean;
-    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<{
+export declare class ZkSyncBalanceProvider extends BalanceProvider {
+    supportsNetwork: (network: NetworkWithTokens) => boolean;
+    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<import("../../../Models/Balance").TokenBalance[] | {
         network: string;
         token: string;
         amount: number;
@@ -10,6 +10,7 @@ export declare class ZkSyncBalanceProvider {
         isNativeCurrency: boolean;
     }[] | undefined>;
 }
+import { BalanceProvider } from "../../../Models/BalanceProvider";
 type Balances = {
     [currency: string]: string;
 };

package/dist/lib/balances/providers/zkSyncBalanceProvider.js

@@ -1,32 +1,44 @@
-import formatAmount from "../../formatAmount";
-import KnownInternalNames from "../../knownIds";
-export class ZkSyncBalanceProvider {
+import formatAmount from "../../../lib/formatAmount";
+import KnownInternalNames from "../../../lib/knownIds";
+export class ZkSyncBalanceProvider extends BalanceProvider {
     constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return KnownInternalNames.Networks.ZksyncMainnet.includes(network.name);
+        };
         this.fetchBalance = async (address, network) => {
             const client = new ZkSyncLiteRPCClient();
             const tokens = insertIfNotExists(network.tokens || [], network.token);
             if (!network?.tokens)
                 return;
-            const result = await client.getAccountInfo(network.node_url, address);
-            const zkSyncBalances = tokens.map((currency) => {
-                const amount = currency && result.committed.balances[currency.symbol];
-                return ({
-                    network: network.name,
-                    token: currency.symbol,
-                    amount: formatAmount(amount, Number(currency?.decimals)),
-                    request_time: new Date().toJSON(),
-                    decimals: Number(currency?.decimals),
-                    isNativeCurrency: true
+            try {
+                const result = await client.getAccountInfo(network.node_url, address);
+                const zkSyncBalances = tokens.map((currency) => {
+                    const amount = currency && result.committed.balances[currency.symbol];
+                    return ({
+                        network: network.name,
+                        token: currency.symbol,
+                        amount: formatAmount(amount, Number(currency?.decimals)),
+                        request_time: new Date().toJSON(),
+                        decimals: Number(currency?.decimals),
+                        isNativeCurrency: true
+                    });
                 });
-            });
-            return zkSyncBalances;
+                return zkSyncBalances;
+            }
+            catch (e) {
+                const error = {
+                    message: e?.message ?? "Failed get token balance",
+                    code: e?.code,
+                    cause: e,
+                };
+                return tokens.map((currency) => (this.resolveTokenBalanceFetchError(error, currency, network)));
+            }
         };
     }
-    supportsNetwork(network) {
-        return KnownInternalNames.Networks.ZksyncMainnet.includes(network.name);
-    }
 }
-import { insertIfNotExists } from "./helpers";
+import { insertIfNotExists } from "../helpers";
+import { BalanceProvider } from "../../../Models/BalanceProvider";
 export default class ZkSyncLiteRPCClient {
     async getPublicClient(nodeUrl) {
         if (this._client == undefined) {

package/dist/lib/balances/useBalance.d.ts

@@ -0,0 +1,14 @@
+import { NetworkWithTokens } from '../../Models/Network';
+export interface Opts {
+    refreshInterval?: number;
+    dedupeInterval?: number;
+    refreshWhenHidden?: boolean;
+    refreshWhenOffline?: boolean;
+}
+export declare function useBalance(address: string | undefined, network: NetworkWithTokens | undefined, opts?: Opts): {
+    balances: import("../../Models/Balance").TokenBalance[] | null | undefined;
+    totalInUSD: number | undefined;
+    error: unknown;
+    isLoading: boolean;
+    mutate: () => void;
+};

package/dist/lib/balances/useBalance.js

@@ -0,0 +1,48 @@
+import { useEffect, useMemo } from 'react';
+import { getKey, useBalanceStore } from '../../stores/balanceStore';
+export function useBalance(address, network, opts) {
+    const key = useMemo(() => (address && network) ? getKey(address, network) : 'unknown', [address, network]);
+    const { refreshInterval = 60000, refreshWhenHidden = false, refreshWhenOffline = false, dedupeInterval = 60000, } = opts ?? {};
+    const entry = useBalanceStore((s) => s.balances[key]);
+    const fetchBalance = useBalanceStore((s) => s.fetchBalance);
+    const tick = (interval = refreshInterval) => {
+        if (!address || !network)
+            return;
+        if (refreshWhenHidden && document.hidden)
+            return;
+        if (refreshWhenOffline && !navigator.onLine)
+            return;
+        fetchBalance(address, network, { dedupeInterval: interval });
+    };
+    useEffect(() => {
+        tick();
+    }, [address, network, entry?.status, fetchBalance]);
+    useEffect(() => {
+        if (refreshInterval <= 0)
+            return;
+        if (!address || !network)
+            return;
+        tick(refreshInterval);
+        const id = window.setInterval(tick, refreshInterval);
+        return () => window.clearInterval(id);
+    }, [
+        address,
+        network,
+        fetchBalance,
+        refreshInterval,
+        refreshWhenHidden,
+        refreshWhenOffline,
+    ]);
+    const mutate = () => {
+        if (!address || !network)
+            return;
+        fetchBalance(address, network, { ignoreCache: true });
+    };
+    return {
+        balances: entry?.data?.balances,
+        totalInUSD: entry?.data?.totalInUSD,
+        error: entry?.error,
+        isLoading: entry?.status === 'loading',
+        mutate,
+    };
+}

package/dist/lib/fuels/common/FakeAccount.d.ts

@@ -0,0 +1,24 @@
+import type { Hash, Option } from './types';
+export interface FakeAccount {
+    generate: () => void;
+    getAddress: () => Option<string, Hash>;
+    getRawAddress: () => Uint8Array;
+    signMessage: (message: Option<string, Uint8Array, Hash>) => Promise<Option<string, Uint8Array, Hash>>;
+}
+export declare class EthereumFakeAccount implements FakeAccount {
+    private account;
+    constructor();
+    generate: () => void;
+    getAddress: () => Option<string, Hash>;
+    getRawAddress: () => Uint8Array;
+    signMessage: (message: Option<string, Uint8Array, Hash>) => Promise<Option<string, Uint8Array, Hash>>;
+}
+export declare class SolanaFakeAccount implements FakeAccount {
+    private keypair;
+    constructor();
+    generate: () => void;
+    getAddress: () => Option<string, Hash>;
+    getRawAddress: () => Uint8Array;
+    private getSmallTxId;
+    signMessage: (message: Option<string, Uint8Array, Hash>) => Promise<Option<string, Uint8Array, Hash>>;
+}

package/dist/lib/fuels/common/FakeAccount.js

@@ -1,58 +1,36 @@
-// import { Keypair } from '@solana/web3.js';
-// import nacl from 'tweetnacl';
-// import { type PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
-// import type { Hash, Option } from './types';
-// export interface FakeAccount {
-//   generate: () => void;
-//   getAddress: () => Option<string, Hash>;
-//   getRawAddress: () => Uint8Array;
-//   signMessage: (
-//     message: Option<string, Uint8Array, Hash>,
-//   ) => Promise<Option<string, Uint8Array, Hash>>;
-// }
-// export class EthereumFakeAccount implements FakeAccount {
-//   private account!: PrivateKeyAccount;
-//   constructor() {
-//     this.generate();
-//   }
-//   generate = (): void => {
-//     this.account = privateKeyToAccount(
-//       '0x0000000000000000000000000000000000000000000000000000000000000001',
-//     );
-//   };
-//   getAddress = (): Option<string, Hash> => this.account.address;
-//   getRawAddress = (): Uint8Array =>
-//     Buffer.from(this.account.address.slice(2), 'hex');
-//   signMessage = (
-//     message: Option<string, Uint8Array, Hash>,
-//   ): Promise<Option<string, Uint8Array, Hash>> => {
-//     return this.account.signMessage({
-//       message: message as string,
-//     });
-//   };
-// }
-// export class SolanaFakeAccount implements FakeAccount {
-//   private keypair!: Keypair;
-//   constructor() {
-//     this.generate();
-//   }
-//   generate = (): void => {
-//     this.keypair = Keypair.generate();
-//   };
-//   getAddress = (): Option<string, Hash> => this.keypair.publicKey.toString();
-//   getRawAddress = (): Uint8Array => this.keypair.publicKey.toBytes();
-//   private getSmallTxId = (
-//     message: Option<string, Uint8Array, Hash>,
-//   ): Uint8Array => {
-//     const txIdNo0x = message.slice(2);
-//     const idBytes = `${txIdNo0x.slice(0, 16)}${txIdNo0x.slice(-16)}`;
-//     return new TextEncoder().encode(idBytes);
-//   };
-//   signMessage = (
-//     message: Option<string, Uint8Array, Hash>,
-//   ): Promise<Option<string, Uint8Array, Hash>> => {
-//     return Promise.resolve(
-//       nacl.sign.detached(this.getSmallTxId(message), this.keypair.secretKey),
-//     );
-//   };
-// }
+import { Keypair } from '@solana/web3.js';
+import nacl from 'tweetnacl';
+import { privateKeyToAccount } from 'viem/accounts';
+export class EthereumFakeAccount {
+    constructor() {
+        this.generate = () => {
+            this.account = privateKeyToAccount('0x0000000000000000000000000000000000000000000000000000000000000001');
+        };
+        this.getAddress = () => this.account.address;
+        this.getRawAddress = () => Buffer.from(this.account.address.slice(2), 'hex');
+        this.signMessage = (message) => {
+            return this.account.signMessage({
+                message: message,
+            });
+        };
+        this.generate();
+    }
+}
+export class SolanaFakeAccount {
+    constructor() {
+        this.generate = () => {
+            this.keypair = Keypair.generate();
+        };
+        this.getAddress = () => this.keypair.publicKey.toString();
+        this.getRawAddress = () => this.keypair.publicKey.toBytes();
+        this.getSmallTxId = (message) => {
+            const txIdNo0x = message.slice(2);
+            const idBytes = `${txIdNo0x.slice(0, 16)}${txIdNo0x.slice(-16)}`;
+            return new TextEncoder().encode(idBytes);
+        };
+        this.signMessage = (message) => {
+            return Promise.resolve(nacl.sign.detached(this.getSmallTxId(message), this.keypair.secretKey));
+        };
+        this.generate();
+    }
+}

package/dist/lib/fuels/common/PredicateConnector.d.ts

@@ -0,0 +1,78 @@
+import { type AbiMap, type Asset, type BytesLike, type ConnectorMetadata, FuelConnector, FuelConnectorEventTypes, type HashableMessage, type JsonAbi, type Network, type SelectNetworkArguments, type TransactionRequestLike, type TransactionResponse, type Version } from 'fuels';
+import { PredicateFactory } from './PredicateFactory';
+import type { PredicateWalletAdapter } from './PredicateWalletAdapter';
+import type { ConnectorConfig, Maybe, MaybeAsync, PredicateConfig, PredicateVersion, PredicateVersionWithMetadata, PreparedTransaction, ProviderDictionary, SignedMessageCustomCurve } from './types';
+export declare abstract class PredicateConnector extends FuelConnector {
+    connected: boolean;
+    installed: boolean;
+    external: boolean;
+    events: typeof FuelConnectorEventTypes;
+    protected predicateAddress: string;
+    protected customPredicate: Maybe<PredicateConfig>;
+    protected predicateAccount: Maybe<PredicateFactory>;
+    protected subscriptions: Array<() => void>;
+    protected hasProviderSucceeded: boolean;
+    protected selectedPredicateVersion: Maybe<string>;
+    private _predicateVersions;
+    abstract name: string;
+    abstract metadata: ConnectorMetadata;
+    abstract sendTransaction(address: string, transaction: TransactionRequestLike): Promise<string | TransactionResponse>;
+    abstract connect(): Promise<boolean>;
+    /**
+     * Derived classes MUST call `await super.disconnect();` as part of their
+     * disconnection logic. They remain responsible for their specific
+     * disconnection procedures (e.g., from the underlying wallet),
+     * updating `this.connected` status, and emitting events such as
+     * `connection`, `currentAccount`, and `accounts`.
+     * @returns A promise that resolves to true if the base cleanup is successful.
+     */
+    disconnect(): Promise<boolean>;
+    protected abstract configProviders(config: ConnectorConfig): MaybeAsync<void>;
+    protected abstract getWalletAdapter(): PredicateWalletAdapter;
+    protected abstract getPredicateVersions(): Record<string, PredicateVersion>;
+    protected abstract getAccountAddress(): MaybeAsync<Maybe<string>>;
+    protected abstract getProviders(): Promise<ProviderDictionary>;
+    protected abstract requireConnection(): MaybeAsync<void>;
+    protected abstract walletAccounts(): Promise<Array<string>>;
+    abstract signMessageCustomCurve(_message: string): Promise<SignedMessageCustomCurve>;
+    constructor();
+    protected emitAccountChange(address: string, connected?: boolean): Promise<void>;
+    protected get predicateVersions(): Array<PredicateFactory>;
+    getAvailablePredicateVersions(): Array<{
+        id: string;
+        generatedAt: number;
+    }>;
+    /**
+     * Get all predicate versions including metadata
+     * @returns Promise that resolves to the array of predicate versions with complete metadata
+     */
+    getAllPredicateVersionsWithMetadata(): Promise<PredicateVersionWithMetadata[]>;
+    setSelectedPredicateVersion(versionId: string): void;
+    getSelectedPredicateVersion(): Maybe<string>;
+    getSmartDefaultPredicateVersion(): Promise<Maybe<string>>;
+    switchPredicateVersion(versionId: string): Promise<void>;
+    protected isAddressPredicate(b: BytesLike, walletAccount: string): boolean;
+    protected getCurrentUserPredicate(): Promise<Maybe<PredicateFactory>>;
+    protected getNewestPredicate(): Maybe<PredicateFactory>;
+    protected getPredicateByVersion(versionId: string): Maybe<PredicateFactory>;
+    protected setupPredicate(): Promise<PredicateFactory>;
+    protected subscribe(listener: () => void): void;
+    protected prepareTransaction(address: string, transaction: TransactionRequestLike): Promise<PreparedTransaction>;
+    clearSubscriptions(): void;
+    ping(): Promise<boolean>;
+    version(): Promise<Version>;
+    isConnected(): Promise<boolean>;
+    accounts(): Promise<Array<string>>;
+    currentAccount(): Promise<string | null>;
+    networks(): Promise<Network[]>;
+    currentNetwork(): Promise<Network>;
+    signMessage(_address: string, _message: HashableMessage): Promise<string>;
+    addAssets(_assets: Asset[]): Promise<boolean>;
+    addAsset(_asset: Asset): Promise<boolean>;
+    assets(): Promise<Array<Asset>>;
+    addNetwork(_networkUrl: string): Promise<boolean>;
+    selectNetwork(_network: SelectNetworkArguments): Promise<boolean>;
+    addAbi(_abiMap: AbiMap): Promise<boolean>;
+    getAbi(_contractId: string): Promise<JsonAbi>;
+    hasAbi(_contractId: string): Promise<boolean>;
+}