@huma-finance/shared 0.0.36 → 0.0.37

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

@@ -1,140 +1,140 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { hexToUtf8 } from './lib';
-import { call, getChainId, signData } from './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) => hexToUtf8((await 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),
-        getChainId(provider),
-    ]);
-    const domain = {
-        name,
-        version: '1',
-        chainId,
-        verifyingContract: tokenAddress,
-    };
-    return domain;
-};
-export const signDaiPermit = async (provider, token, holder, spender, expiry, nonce) => {
-    const tokenAddress = token.verifyingContract || token;
-    const message = {
-        holder,
-        spender,
-        nonce: nonce === undefined
-            ? await 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 signData(provider, holder, typedData);
-    return Object.assign(Object.assign({}, sig), message);
-};
-export 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 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 signData(provider, owner, typedData);
-    return Object.assign(Object.assign({}, sig), message);
-};
-export 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 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 signData(provider, receiver, typedData);
-    return Object.assign(Object.assign({}, sig), message);
-};
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { hexToUtf8 } from './lib';
+import { call, getChainId, signData } from './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) => hexToUtf8((await 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),
+        getChainId(provider),
+    ]);
+    const domain = {
+        name,
+        version: '1',
+        chainId,
+        verifyingContract: tokenAddress,
+    };
+    return domain;
+};
+export const signDaiPermit = async (provider, token, holder, spender, expiry, nonce) => {
+    const tokenAddress = token.verifyingContract || token;
+    const message = {
+        holder,
+        spender,
+        nonce: nonce === undefined
+            ? await 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 signData(provider, holder, typedData);
+    return Object.assign(Object.assign({}, sig), message);
+};
+export 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 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 signData(provider, owner, typedData);
+    return Object.assign(Object.assign({}, sig), message);
+};
+export 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 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 signData(provider, receiver, typedData);
+    return Object.assign(Object.assign({}, sig), message);
+};
 //# sourceMappingURL=index.js.map

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

@@ -1,22 +1,22 @@
-import utf8 from 'utf8';
-export 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.decode(str);
-};
+import utf8 from 'utf8';
+export 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.decode(str);
+};
 //# sourceMappingURL=lib.js.map

package/dist/hooks/useERC2612Permit/ethPermit/rpc.js

@@ -1,97 +1,97 @@
-import { __rest } from "tslib";
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const randomId = () => Math.floor(Math.random() * 10000000000);
-export const send = (provider, method, params) => new Promise((resolve, reject) => {
-    const payload = {
-        id: randomId(),
-        method,
-        params,
-    };
-    const callback = (err, result) => {
-        if (err) {
-            reject(err);
-        }
-        else if (result.error) {
-            console.error(result.error);
-            reject(result.error);
-        }
-        else {
-            resolve(result.result);
-        }
-    };
-    if (provider.getUncheckedSigner /* ethers provider */) {
-        provider
-            .send(method, params)
-            .then((r) => resolve(r))
-            .catch((e) => reject(e));
-    }
-    else if (provider.sendAsync) {
-        provider.sendAsync(payload, callback);
-    }
-    else {
-        provider.send(payload, callback).catch((error) => {
-            if (error.message ===
-                "Hardhat Network doesn't support JSON-RPC params sent as an object") {
-                provider
-                    .send(method, params)
-                    .then((r) => resolve(r))
-                    .catch((e) => reject(e));
-            }
-            else {
-                throw error;
-            }
-        });
-    }
-});
-const splitSignatureToRSV = (signature) => {
-    const r = `0x${signature.substring(2).substring(0, 64)}`;
-    const s = `0x${signature.substring(2).substring(64, 128)}`;
-    const v = parseInt(signature.substring(2).substring(128, 130), 16);
-    return { r, s, v };
-};
-const signWithEthers = async (signer, fromAddress, typeData) => {
-    const signerAddress = await signer.getAddress();
-    if (signerAddress.toLowerCase() !== fromAddress.toLowerCase()) {
-        throw new Error('Signer address does not match requested signing address');
-    }
-    const _a = typeData.types, { EIP712Domain: _unused } = _a, types = __rest(_a, ["EIP712Domain"]);
-    const rawSignature = await (signer.signTypedData
-        ? signer.signTypedData(typeData.domain, types, typeData.message)
-        : signer._signTypedData(typeData.domain, types, typeData.message));
-    return splitSignatureToRSV(rawSignature);
-};
-export const signData = async (provider, fromAddress, typeData) => {
-    if (provider._signTypedData || provider.signTypedData) {
-        return signWithEthers(provider, fromAddress, typeData);
-    }
-    const typeDataString = typeof typeData === 'string' ? typeData : JSON.stringify(typeData);
-    const result = await send(provider, 'eth_signTypedData_v4', [
-        fromAddress,
-        typeDataString,
-    ]).catch((error) => {
-        if (error.message === 'Method eth_signTypedData_v4 not supported.') {
-            return send(provider, 'eth_signTypedData', [fromAddress, typeData]);
-        }
-        throw error;
-    });
-    return {
-        r: result.slice(0, 66),
-        s: `0x${result.slice(66, 130)}`,
-        v: parseInt(result.slice(130, 132), 16),
-    };
-};
-let chainIdOverride = null;
-export const setChainIdOverride = (id) => {
-    chainIdOverride = id;
-};
-export const getChainId = async (provider) => chainIdOverride || send(provider, 'eth_chainId');
-export const call = (provider, to, data) => send(provider, 'eth_call', [
-    {
-        to,
-        data,
-    },
-    'latest',
-]);
+import { __rest } from "tslib";
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const randomId = () => Math.floor(Math.random() * 10000000000);
+export const send = (provider, method, params) => new Promise((resolve, reject) => {
+    const payload = {
+        id: randomId(),
+        method,
+        params,
+    };
+    const callback = (err, result) => {
+        if (err) {
+            reject(err);
+        }
+        else if (result.error) {
+            console.error(result.error);
+            reject(result.error);
+        }
+        else {
+            resolve(result.result);
+        }
+    };
+    if (provider.getUncheckedSigner /* ethers provider */) {
+        provider
+            .send(method, params)
+            .then((r) => resolve(r))
+            .catch((e) => reject(e));
+    }
+    else if (provider.sendAsync) {
+        provider.sendAsync(payload, callback);
+    }
+    else {
+        provider.send(payload, callback).catch((error) => {
+            if (error.message ===
+                "Hardhat Network doesn't support JSON-RPC params sent as an object") {
+                provider
+                    .send(method, params)
+                    .then((r) => resolve(r))
+                    .catch((e) => reject(e));
+            }
+            else {
+                throw error;
+            }
+        });
+    }
+});
+const splitSignatureToRSV = (signature) => {
+    const r = `0x${signature.substring(2).substring(0, 64)}`;
+    const s = `0x${signature.substring(2).substring(64, 128)}`;
+    const v = parseInt(signature.substring(2).substring(128, 130), 16);
+    return { r, s, v };
+};
+const signWithEthers = async (signer, fromAddress, typeData) => {
+    const signerAddress = await signer.getAddress();
+    if (signerAddress.toLowerCase() !== fromAddress.toLowerCase()) {
+        throw new Error('Signer address does not match requested signing address');
+    }
+    const _a = typeData.types, { EIP712Domain: _unused } = _a, types = __rest(_a, ["EIP712Domain"]);
+    const rawSignature = await (signer.signTypedData
+        ? signer.signTypedData(typeData.domain, types, typeData.message)
+        : signer._signTypedData(typeData.domain, types, typeData.message));
+    return splitSignatureToRSV(rawSignature);
+};
+export const signData = async (provider, fromAddress, typeData) => {
+    if (provider._signTypedData || provider.signTypedData) {
+        return signWithEthers(provider, fromAddress, typeData);
+    }
+    const typeDataString = typeof typeData === 'string' ? typeData : JSON.stringify(typeData);
+    const result = await send(provider, 'eth_signTypedData_v4', [
+        fromAddress,
+        typeDataString,
+    ]).catch((error) => {
+        if (error.message === 'Method eth_signTypedData_v4 not supported.') {
+            return send(provider, 'eth_signTypedData', [fromAddress, typeData]);
+        }
+        throw error;
+    });
+    return {
+        r: result.slice(0, 66),
+        s: `0x${result.slice(66, 130)}`,
+        v: parseInt(result.slice(130, 132), 16),
+    };
+};
+let chainIdOverride = null;
+export const setChainIdOverride = (id) => {
+    chainIdOverride = id;
+};
+export const getChainId = async (provider) => chainIdOverride || send(provider, 'eth_chainId');
+export const call = (provider, to, data) => send(provider, 'eth_call', [
+    {
+        to,
+        data,
+    },
+    'latest',
+]);
 //# sourceMappingURL=rpc.js.map

package/dist/hooks/useERC2612Permit/index.js

@@ -1,32 +1,32 @@
-import { useWeb3React } from '@web3-react/core';
-import { useCallback } from 'react';
-import { signERC2612Permit, signTradableStreamPermit } from './ethPermit';
-export const useERC2612Permit = () => {
-    const { account, provider, chainId } = useWeb3React();
-    const getDeadline = useCallback(async () => {
-        const FIVE_MINUTES = 5 * 60;
-        const latestBlock = await provider.getBlock('latest');
-        return latestBlock.timestamp + FIVE_MINUTES;
-    }, [provider]);
-    const getERC2612PermitMessage = useCallback(async (tokenAddress, spender, amount) => {
-        const deadline = await getDeadline();
-        const result = await signERC2612Permit(provider, tokenAddress, account, spender, amount, deadline);
-        return result;
-    }, [account, getDeadline, provider]);
-    const getTradableStreamPermitMessage = useCallback(async (NFT, receiver, tokenAddress, origin, owner, flowrate, durationInSeconds) => {
-        const domain = {
-            name: 'TradableStream',
-            version: '1',
-            chainId: chainId,
-            verifyingContract: NFT,
-        };
-        const deadline = await getDeadline();
-        const result = await signTradableStreamPermit(provider, domain, receiver, tokenAddress, origin, owner, flowrate, durationInSeconds, deadline);
-        return result;
-    }, [chainId, getDeadline, provider]);
-    return {
-        getERC2612PermitMessage,
-        getTradableStreamPermitMessage,
-    };
-};
+import { useWeb3React } from '@web3-react/core';
+import { useCallback } from 'react';
+import { signERC2612Permit, signTradableStreamPermit } from './ethPermit';
+export const useERC2612Permit = () => {
+    const { account, provider, chainId } = useWeb3React();
+    const getDeadline = useCallback(async () => {
+        const FIVE_MINUTES = 5 * 60;
+        const latestBlock = await provider.getBlock('latest');
+        return latestBlock.timestamp + FIVE_MINUTES;
+    }, [provider]);
+    const getERC2612PermitMessage = useCallback(async (tokenAddress, spender, amount) => {
+        const deadline = await getDeadline();
+        const result = await signERC2612Permit(provider, tokenAddress, account, spender, amount, deadline);
+        return result;
+    }, [account, getDeadline, provider]);
+    const getTradableStreamPermitMessage = useCallback(async (NFT, receiver, tokenAddress, origin, owner, flowrate, durationInSeconds) => {
+        const domain = {
+            name: 'TradableStream',
+            version: '1',
+            chainId: chainId,
+            verifyingContract: NFT,
+        };
+        const deadline = await getDeadline();
+        const result = await signTradableStreamPermit(provider, domain, receiver, tokenAddress, origin, owner, flowrate, durationInSeconds, deadline);
+        return result;
+    }, [chainId, getDeadline, provider]);
+    return {
+        getERC2612PermitMessage,
+        getTradableStreamPermitMessage,
+    };
+};
 //# sourceMappingURL=index.js.map