@huma-finance/shared 0.0.28 → 0.0.29

package/dist/cjs/hooks/useContractFunction.d.ts

@@ -1,18 +1,18 @@
-import { Contract, ContractReceipt } from '@ethersproject/contracts';
-import { Web3Provider } from '@ethersproject/providers';
-import { TxStateType } from '../utils/transaction';
-interface TxStateManagement {
-    state: TxStateType;
-    txHash: string;
-    txReceipt: ContractReceipt | undefined;
-    loading: boolean;
-    failReason: string;
-}
-export declare const txAtom: import("jotai").WritableAtom<TxStateManagement, TxStateManagement | typeof import("jotai/utils").RESET | ((prev: TxStateManagement) => TxStateManagement | typeof import("jotai/utils").RESET), void>;
-export declare const sendTxAtom: import("jotai").WritableAtom<TxStateManagement, {
-    contract: Contract;
-    method: string;
-    params: any[];
-    provider: Web3Provider | undefined;
-}, Promise<void>>;
-export {};
+import { Contract, ContractReceipt } from '@ethersproject/contracts';
+import { Web3Provider } from '@ethersproject/providers';
+import { TxStateType } from '../utils/transaction';
+interface TxStateManagement {
+    state: TxStateType;
+    txHash: string;
+    txReceipt: ContractReceipt | undefined;
+    loading: boolean;
+    failReason: string;
+}
+export declare const txAtom: import("jotai").WritableAtom<TxStateManagement, TxStateManagement | typeof import("jotai/utils").RESET | ((prev: TxStateManagement) => TxStateManagement | typeof import("jotai/utils").RESET), void>;
+export declare const sendTxAtom: import("jotai").WritableAtom<TxStateManagement, {
+    contract: Contract;
+    method: string;
+    params: any[];
+    provider: Web3Provider | undefined;
+}, Promise<void>>;
+export {};

package/dist/cjs/hooks/useContractFunction.js

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendTxAtom = exports.txAtom = void 0;
-const jotai_1 = require("jotai");
-const utils_1 = require("jotai/utils");
-const transaction_1 = require("../utils/transaction");
-const txInitManagement = {
-    state: transaction_1.TxStateType.New,
-    txHash: '',
-    txReceipt: undefined,
-    loading: false,
-    failReason: '',
-};
-exports.txAtom = (0, utils_1.atomWithReset)(txInitManagement);
-exports.sendTxAtom = (0, jotai_1.atom)((get) => get(exports.txAtom), 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async (get, set, payload) => {
-    const { contract, method, params, provider } = payload;
-    try {
-        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { loading: true }));
-        const gasLimit = await contract.estimateGas[method](...params);
-        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Signing }));
-        const tx = await contract[method](...params, {
-            gasLimit: (0, transaction_1.increaseGasLimit)(gasLimit),
-        });
-        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Confirming, txHash: tx.hash }));
-        const txReceipt = await tx.wait();
-        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { txReceipt }));
-        // tx was mined successfully
-        if (txReceipt.status === 1) {
-            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Success, loading: false }));
-        }
-        else {
-            let failReason = 'Send transaction failed';
-            if (provider) {
-                const failReasonReturned = await (0, transaction_1.getTransactionErrorFromHash)(provider, tx.hash);
-                if (failReasonReturned) {
-                    failReason = failReasonReturned;
-                }
-            }
-            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Failed, loading: false, failReason }));
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (e) {
-        const contractErrorMessage = (0, transaction_1.getTransactionErrorFromError)(e);
-        if (contractErrorMessage) {
-            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Failed, loading: false, failReason: contractErrorMessage }));
-            return;
-        }
-        if (e.code === 4001 || e.code === 'ACTION_REJECTED') {
-            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Denied, loading: false, failReason: 'User has rejected the transaction' }));
-            return;
-        }
-        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Invalid, loading: false, failReason: e.reason || `Send transaction failed` }));
-    }
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTxAtom = exports.txAtom = void 0;
+const jotai_1 = require("jotai");
+const utils_1 = require("jotai/utils");
+const transaction_1 = require("../utils/transaction");
+const txInitManagement = {
+    state: transaction_1.TxStateType.New,
+    txHash: '',
+    txReceipt: undefined,
+    loading: false,
+    failReason: '',
+};
+exports.txAtom = (0, utils_1.atomWithReset)(txInitManagement);
+exports.sendTxAtom = (0, jotai_1.atom)((get) => get(exports.txAtom), 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async (get, set, payload) => {
+    const { contract, method, params, provider } = payload;
+    try {
+        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { loading: true }));
+        const gasLimit = await contract.estimateGas[method](...params);
+        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Signing }));
+        const tx = await contract[method](...params, {
+            gasLimit: (0, transaction_1.increaseGasLimit)(gasLimit),
+        });
+        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Confirming, txHash: tx.hash }));
+        const txReceipt = await tx.wait();
+        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { txReceipt }));
+        // tx was mined successfully
+        if (txReceipt.status === 1) {
+            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Success, loading: false }));
+        }
+        else {
+            let failReason = 'Send transaction failed';
+            if (provider) {
+                const failReasonReturned = await (0, transaction_1.getTransactionErrorFromHash)(provider, tx.hash);
+                if (failReasonReturned) {
+                    failReason = failReasonReturned;
+                }
+            }
+            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Failed, loading: false, failReason }));
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (e) {
+        const contractErrorMessage = (0, transaction_1.getTransactionErrorFromError)(e);
+        if (contractErrorMessage) {
+            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Failed, loading: false, failReason: contractErrorMessage }));
+            return;
+        }
+        if (e.code === 4001 || e.code === 'ACTION_REJECTED') {
+            set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Denied, loading: false, failReason: 'User has rejected the transaction' }));
+            return;
+        }
+        set(exports.txAtom, Object.assign(Object.assign({}, get(exports.txAtom)), { state: transaction_1.TxStateType.Invalid, loading: false, failReason: e.reason || `Send transaction failed` }));
+    }
+});
 //# sourceMappingURL=useContractFunction.js.map

package/dist/cjs/hooks/useERC2612Permit/ethPermit/index.d.ts

@@ -1,35 +1,35 @@
-import { RSV } from './rpc';
-export interface DaiPermitMessage {
-    holder: string;
-    spender: string;
-    nonce: number;
-    expiry: number | string;
-    allowed?: boolean;
-}
-export interface ERC2612PermitMessage {
-    owner: string;
-    spender: string;
-    value: number | string;
-    nonce: number | string;
-    deadline: number | string;
-}
-export interface TradableStreamPermitMessage {
-    owner: string;
-    receiver: string;
-    token: string;
-    origin: string;
-    flowrate: string;
-    durationInSeconds: number;
-    nonce: number | string;
-    expiry: number | string;
-}
-interface Domain {
-    name: string;
-    version: string;
-    chainId: number;
-    verifyingContract: string;
-}
-export declare const signDaiPermit: (provider: any, token: string | Domain, holder: string, spender: string, expiry?: number, nonce?: number) => Promise<DaiPermitMessage & RSV>;
-export declare const signERC2612Permit: (provider: any, token: string | Domain, owner: string, spender: string, value?: string | number, deadline?: number, nonce?: number) => Promise<ERC2612PermitMessage & RSV>;
-export declare const signTradableStreamPermit: (provider: any, NFT: string | Domain, receiver: string, token: string, origin: string, owner: string, flowrate: string, durationInSeconds: number, expiry?: number, nonce?: number) => Promise<TradableStreamPermitMessage & RSV>;
-export {};
+import { RSV } from './rpc';
+export interface DaiPermitMessage {
+    holder: string;
+    spender: string;
+    nonce: number;
+    expiry: number | string;
+    allowed?: boolean;
+}
+export interface ERC2612PermitMessage {
+    owner: string;
+    spender: string;
+    value: number | string;
+    nonce: number | string;
+    deadline: number | string;
+}
+export interface TradableStreamPermitMessage {
+    owner: string;
+    receiver: string;
+    token: string;
+    origin: string;
+    flowrate: string;
+    durationInSeconds: number;
+    nonce: number | string;
+    expiry: number | string;
+}
+interface Domain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+}
+export declare const signDaiPermit: (provider: any, token: string | Domain, holder: string, spender: string, expiry?: number, nonce?: number) => Promise<DaiPermitMessage & RSV>;
+export declare const signERC2612Permit: (provider: any, token: string | Domain, owner: string, spender: string, value?: string | number, deadline?: number, nonce?: number) => Promise<ERC2612PermitMessage & RSV>;
+export declare const signTradableStreamPermit: (provider: any, NFT: string | Domain, receiver: string, token: string, origin: string, owner: string, flowrate: string, durationInSeconds: number, expiry?: number, nonce?: number) => Promise<TradableStreamPermitMessage & RSV>;
+export {};

package/dist/cjs/hooks/useERC2612Permit/ethPermit/index.js

@@ -1,146 +1,146 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.signTradableStreamPermit = exports.signERC2612Permit = exports.signDaiPermit = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const lib_1 = require("./lib");
-const rpc_1 = require("./rpc");
-const MAX_INT = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
-const EIP712Domain = [
-    { name: 'name', type: 'string' },
-    { name: 'version', type: 'string' },
-    { name: 'chainId', type: 'uint256' },
-    { name: 'verifyingContract', type: 'address' },
-];
-const createTypedDaiData = (message, domain) => {
-    const typedData = {
-        types: {
-            EIP712Domain,
-            Permit: [
-                { name: 'holder', type: 'address' },
-                { name: 'spender', type: 'address' },
-                { name: 'nonce', type: 'uint256' },
-                { name: 'expiry', type: 'uint256' },
-                { name: 'allowed', type: 'bool' },
-            ],
-        },
-        primaryType: 'Permit',
-        domain,
-        message,
-    };
-    return typedData;
-};
-const createTypedERC2612Data = (message, domain) => {
-    const typedData = {
-        types: {
-            EIP712Domain,
-            Permit: [
-                { name: 'owner', type: 'address' },
-                { name: 'spender', type: 'address' },
-                { name: 'value', type: 'uint256' },
-                { name: 'nonce', type: 'uint256' },
-                { name: 'deadline', type: 'uint256' },
-            ],
-        },
-        primaryType: 'Permit',
-        domain,
-        message,
-    };
-    return typedData;
-};
-const createTypedTradableStreamData = (message, domain) => {
-    const typedData = {
-        types: {
-            EIP712Domain,
-            MintToWithAuthorization: [
-                { name: 'receiver', type: 'address' },
-                { name: 'token', type: 'address' },
-                { name: 'origin', type: 'address' },
-                { name: 'owner', type: 'address' },
-                { name: 'flowrate', type: 'int96' },
-                { name: 'durationInSeconds', type: 'uint256' },
-                { name: 'nonce', type: 'uint256' },
-                { name: 'expiry', type: 'uint256' },
-            ],
-        },
-        primaryType: 'MintToWithAuthorization',
-        domain,
-        message,
-    };
-    return typedData;
-};
-const NONCES_FN = '0x7ecebe00';
-const NAME_FN = '0x06fdde03';
-const zeros = (numZeros) => ''.padEnd(numZeros, '0');
-const getTokenName = async (provider, address) => (0, lib_1.hexToUtf8)((await (0, rpc_1.call)(provider, address, NAME_FN)).substr(130));
-const getDomain = async (provider, token) => {
-    if (typeof token !== 'string') {
-        return token;
-    }
-    const tokenAddress = token;
-    const [name, chainId] = await Promise.all([
-        getTokenName(provider, tokenAddress),
-        (0, rpc_1.getChainId)(provider),
-    ]);
-    const domain = {
-        name,
-        version: '1',
-        chainId,
-        verifyingContract: tokenAddress,
-    };
-    return domain;
-};
-const signDaiPermit = async (provider, token, holder, spender, expiry, nonce) => {
-    const tokenAddress = token.verifyingContract || token;
-    const message = {
-        holder,
-        spender,
-        nonce: nonce === undefined
-            ? await (0, rpc_1.call)(provider, tokenAddress, `${NONCES_FN}${zeros(24)}${holder.substr(2)}`)
-            : nonce,
-        expiry: expiry || MAX_INT,
-        allowed: true,
-    };
-    const domain = await getDomain(provider, token);
-    const typedData = createTypedDaiData(message, domain);
-    const sig = await (0, rpc_1.signData)(provider, holder, typedData);
-    return Object.assign(Object.assign({}, sig), message);
-};
-exports.signDaiPermit = signDaiPermit;
-const signERC2612Permit = async (provider, token, owner, spender, value = MAX_INT, deadline, nonce) => {
-    const tokenAddress = token.verifyingContract || token;
-    const message = {
-        owner,
-        spender,
-        value,
-        nonce: nonce === undefined
-            ? await (0, rpc_1.call)(provider, tokenAddress, `${NONCES_FN}${zeros(24)}${owner.substr(2)}`)
-            : nonce,
-        deadline: deadline || MAX_INT,
-    };
-    const domain = await getDomain(provider, token);
-    const typedData = createTypedERC2612Data(message, domain);
-    const sig = await (0, rpc_1.signData)(provider, owner, typedData);
-    return Object.assign(Object.assign({}, sig), message);
-};
-exports.signERC2612Permit = signERC2612Permit;
-const signTradableStreamPermit = async (provider, NFT, receiver, token, origin, owner, flowrate, durationInSeconds, expiry, nonce) => {
-    const NFTAddress = NFT.verifyingContract || NFT;
-    const message = {
-        receiver,
-        token,
-        origin,
-        owner,
-        flowrate,
-        durationInSeconds,
-        nonce: nonce === undefined
-            ? await (0, rpc_1.call)(provider, NFTAddress, `${NONCES_FN}${zeros(24)}${receiver.substr(2)}`)
-            : nonce,
-        expiry: expiry || MAX_INT,
-    };
-    const domain = await getDomain(provider, NFT);
-    const typedData = createTypedTradableStreamData(message, domain);
-    const sig = await (0, rpc_1.signData)(provider, receiver, typedData);
-    return Object.assign(Object.assign({}, sig), message);
-};
-exports.signTradableStreamPermit = signTradableStreamPermit;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTradableStreamPermit = exports.signERC2612Permit = exports.signDaiPermit = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const lib_1 = require("./lib");
+const rpc_1 = require("./rpc");
+const MAX_INT = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+const EIP712Domain = [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+    { name: 'verifyingContract', type: 'address' },
+];
+const createTypedDaiData = (message, domain) => {
+    const typedData = {
+        types: {
+            EIP712Domain,
+            Permit: [
+                { name: 'holder', type: 'address' },
+                { name: 'spender', type: 'address' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'expiry', type: 'uint256' },
+                { name: 'allowed', type: 'bool' },
+            ],
+        },
+        primaryType: 'Permit',
+        domain,
+        message,
+    };
+    return typedData;
+};
+const createTypedERC2612Data = (message, domain) => {
+    const typedData = {
+        types: {
+            EIP712Domain,
+            Permit: [
+                { name: 'owner', type: 'address' },
+                { name: 'spender', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'deadline', type: 'uint256' },
+            ],
+        },
+        primaryType: 'Permit',
+        domain,
+        message,
+    };
+    return typedData;
+};
+const createTypedTradableStreamData = (message, domain) => {
+    const typedData = {
+        types: {
+            EIP712Domain,
+            MintToWithAuthorization: [
+                { name: 'receiver', type: 'address' },
+                { name: 'token', type: 'address' },
+                { name: 'origin', type: 'address' },
+                { name: 'owner', type: 'address' },
+                { name: 'flowrate', type: 'int96' },
+                { name: 'durationInSeconds', type: 'uint256' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'expiry', type: 'uint256' },
+            ],
+        },
+        primaryType: 'MintToWithAuthorization',
+        domain,
+        message,
+    };
+    return typedData;
+};
+const NONCES_FN = '0x7ecebe00';
+const NAME_FN = '0x06fdde03';
+const zeros = (numZeros) => ''.padEnd(numZeros, '0');
+const getTokenName = async (provider, address) => (0, lib_1.hexToUtf8)((await (0, rpc_1.call)(provider, address, NAME_FN)).substr(130));
+const getDomain = async (provider, token) => {
+    if (typeof token !== 'string') {
+        return token;
+    }
+    const tokenAddress = token;
+    const [name, chainId] = await Promise.all([
+        getTokenName(provider, tokenAddress),
+        (0, rpc_1.getChainId)(provider),
+    ]);
+    const domain = {
+        name,
+        version: '1',
+        chainId,
+        verifyingContract: tokenAddress,
+    };
+    return domain;
+};
+const signDaiPermit = async (provider, token, holder, spender, expiry, nonce) => {
+    const tokenAddress = token.verifyingContract || token;
+    const message = {
+        holder,
+        spender,
+        nonce: nonce === undefined
+            ? await (0, rpc_1.call)(provider, tokenAddress, `${NONCES_FN}${zeros(24)}${holder.substr(2)}`)
+            : nonce,
+        expiry: expiry || MAX_INT,
+        allowed: true,
+    };
+    const domain = await getDomain(provider, token);
+    const typedData = createTypedDaiData(message, domain);
+    const sig = await (0, rpc_1.signData)(provider, holder, typedData);
+    return Object.assign(Object.assign({}, sig), message);
+};
+exports.signDaiPermit = signDaiPermit;
+const signERC2612Permit = async (provider, token, owner, spender, value = MAX_INT, deadline, nonce) => {
+    const tokenAddress = token.verifyingContract || token;
+    const message = {
+        owner,
+        spender,
+        value,
+        nonce: nonce === undefined
+            ? await (0, rpc_1.call)(provider, tokenAddress, `${NONCES_FN}${zeros(24)}${owner.substr(2)}`)
+            : nonce,
+        deadline: deadline || MAX_INT,
+    };
+    const domain = await getDomain(provider, token);
+    const typedData = createTypedERC2612Data(message, domain);
+    const sig = await (0, rpc_1.signData)(provider, owner, typedData);
+    return Object.assign(Object.assign({}, sig), message);
+};
+exports.signERC2612Permit = signERC2612Permit;
+const signTradableStreamPermit = async (provider, NFT, receiver, token, origin, owner, flowrate, durationInSeconds, expiry, nonce) => {
+    const NFTAddress = NFT.verifyingContract || NFT;
+    const message = {
+        receiver,
+        token,
+        origin,
+        owner,
+        flowrate,
+        durationInSeconds,
+        nonce: nonce === undefined
+            ? await (0, rpc_1.call)(provider, NFTAddress, `${NONCES_FN}${zeros(24)}${receiver.substr(2)}`)
+            : nonce,
+        expiry: expiry || MAX_INT,
+    };
+    const domain = await getDomain(provider, NFT);
+    const typedData = createTypedTradableStreamData(message, domain);
+    const sig = await (0, rpc_1.signData)(provider, receiver, typedData);
+    return Object.assign(Object.assign({}, sig), message);
+};
+exports.signTradableStreamPermit = signTradableStreamPermit;
 //# sourceMappingURL=index.js.map

package/dist/cjs/hooks/useERC2612Permit/ethPermit/lib.d.ts

@@ -1 +1 @@
-export declare const hexToUtf8: (hex: string) => string;
+export declare const hexToUtf8: (hex: string) => string;

package/dist/cjs/hooks/useERC2612Permit/ethPermit/lib.js

@@ -1,27 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hexToUtf8 = void 0;
-const tslib_1 = require("tslib");
-const utf8_1 = tslib_1.__importDefault(require("utf8"));
-const hexToUtf8 = (hex) => {
-    // if (!isHexStrict(hex))
-    //     throw new Error('The parameter "'+ hex +'" must be a valid HEX string.');
-    let str = '';
-    let code = 0;
-    hex = hex.replace(/^0x/i, '');
-    // remove 00 padding from either side
-    hex = hex.replace(/^(?:00)*/, '');
-    hex = hex.split('').reverse().join('');
-    hex = hex.replace(/^(?:00)*/, '');
-    hex = hex.split('').reverse().join('');
-    const l = hex.length;
-    for (let i = 0; i < l; i += 2) {
-        code = parseInt(hex.substr(i, 2), 16);
-        // if (code !== 0) {
-        str += String.fromCharCode(code);
-        // }
-    }
-    return utf8_1.default.decode(str);
-};
-exports.hexToUtf8 = hexToUtf8;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToUtf8 = void 0;
+const tslib_1 = require("tslib");
+const utf8_1 = tslib_1.__importDefault(require("utf8"));
+const hexToUtf8 = (hex) => {
+    // if (!isHexStrict(hex))
+    //     throw new Error('The parameter "'+ hex +'" must be a valid HEX string.');
+    let str = '';
+    let code = 0;
+    hex = hex.replace(/^0x/i, '');
+    // remove 00 padding from either side
+    hex = hex.replace(/^(?:00)*/, '');
+    hex = hex.split('').reverse().join('');
+    hex = hex.replace(/^(?:00)*/, '');
+    hex = hex.split('').reverse().join('');
+    const l = hex.length;
+    for (let i = 0; i < l; i += 2) {
+        code = parseInt(hex.substr(i, 2), 16);
+        // if (code !== 0) {
+        str += String.fromCharCode(code);
+        // }
+    }
+    return utf8_1.default.decode(str);
+};
+exports.hexToUtf8 = hexToUtf8;
 //# sourceMappingURL=lib.js.map

package/dist/cjs/hooks/useERC2612Permit/ethPermit/rpc.d.ts

@@ -1,10 +1,10 @@
-export declare const send: (provider: any, method: string, params?: any[]) => Promise<any>;
-export interface RSV {
-    r: string;
-    s: string;
-    v: number;
-}
-export declare const signData: (provider: any, fromAddress: string, typeData: any) => Promise<RSV>;
-export declare const setChainIdOverride: (id: number) => void;
-export declare const getChainId: (provider: any) => Promise<any>;
-export declare const call: (provider: any, to: string, data: string) => Promise<any>;
+export declare const send: (provider: any, method: string, params?: any[]) => Promise<any>;
+export interface RSV {
+    r: string;
+    s: string;
+    v: number;
+}
+export declare const signData: (provider: any, fromAddress: string, typeData: any) => Promise<RSV>;
+export declare const setChainIdOverride: (id: number) => void;
+export declare const getChainId: (provider: any) => Promise<any>;
+export declare const call: (provider: any, to: string, data: string) => Promise<any>;