astra-modal-test 1.0.5 → 1.0.7

package/src/hooks/useContract.js

@@ -1,140 +1,179 @@
-
 import {
-    useChainId,
-    useReadContract,
-    useWriteContract,
-    useConfig,
-    usePublicClient
+  useChainId,
+  useReadContract,
+  useWriteContract,
+  useConfig,
+  usePublicClient,
 } from "wagmi";
 import { waitForTransactionReceipt, readContract } from "@wagmi/core";
 import { useMemo, useCallback } from "react";
-import contractConfig from "../constants/contracts";
+import { useGetContractConfig } from "./useLspApi";
 import useStore from "../store";
-import { formatAssetByDecimal } from "../utils";
+import { formatAssetByDecimal, toBytes32 } from "../utils";
 export function useBridgeContract(account) {
+  const chainId = useChainId();
+  const publicClient = usePublicClient();
+  const { contractConfig } = useGetContractConfig();
 
-    const chainId = useChainId();
-    const publicClient = usePublicClient();
-    const config = contractConfig[chainId];
-
-    const { currentAssetPair } = useStore();
-
-
-    const bridgeContractConfig = useMemo(() => {
-        return {
-            address: config?.Bridge?.address,
-            abi: config?.Bridge?.abi,
-            enabled: !!config && !!account?.address
-        };
-    }, [account?.address, config]);
-
-
-    const tokenContractConfig = useMemo(() => {
-        return {
-            address: currentAssetPair?.token?.address,
-            abi: config?.USDT?.abi,
-            enabled: !!currentAssetPair
-        }
-    }, [config?.USDT?.abi, currentAssetPair])
-
+  const config = useMemo(() => {
+    if (!contractConfig) return null;
+    return contractConfig[chainId];
+  }, [chainId, contractConfig]);
 
+  const { currentAssetPair } = useStore();
 
-    const { data: allowanceRet, isLoading: allowanceLoading, refetch: onReloadAllowance } = useReadContract({
-        ...tokenContractConfig,
-        functionName: "allowance",
-        args: [account?.address, config?.Bridge?.address],
-        enabled: !!account?.address,
-        scopeKey: "allowance"
-    });
-
-    const formatAllowance = useMemo(() => {
-        if (!allowanceRet) return 0;
-        return formatAssetByDecimal(allowanceRet?.toString(), currentAssetPair?.token?.decimal);
-    }, [allowanceRet, currentAssetPair?.token?.decimal])
-
-    const wagmiConfig = useConfig();
-    const { writeContractAsync } = useWriteContract();
-
-    const onApprove = useCallback(
-        async (approveAmount, wait = true) => {
-            //console.log("🚀 ~ onApprove ~ approveAmount:", approveAmount, config?.address)
-            const tx = await writeContractAsync({
-                ...tokenContractConfig,
-                functionName: "approve",
-                args: [config?.Bridge?.address, BigInt(approveAmount)],
-            });
+  const bridgeContractConfig = useMemo(() => {
+    return {
+      address: config?.Bridge?.address,
+      abi: config?.Bridge?.abi,
+      query: {
+        enabled: !!config && !!account?.address,
+      },
+    };
+  }, [account?.address, config]);
 
-            if (wait) {
-                await waitForTransactionReceipt(
-                    wagmiConfig,
-                    {
-                        hash: tx
-                    },
-                    1
-                );
-                if (onReloadAllowance) {
-                    await onReloadAllowance();
-                }
-            }
-            return tx;
-        },
-        [config?.Bridge?.address, onReloadAllowance, tokenContractConfig, wagmiConfig, writeContractAsync]
+  const tokenContractConfig = useMemo(() => {
+    return {
+      address: currentAssetPair?.token?.address,
+      abi: config?.USDT?.abi,
+      query: {
+        enabled: !!currentAssetPair && !!account?.address,
+      },
+    };
+  }, [account?.address, config?.USDT?.abi, currentAssetPair]);
+
+  const {
+    data: allowanceRet,
+    isLoading: allowanceLoading,
+    refetch: onReloadAllowance,
+  } = useReadContract({
+    ...tokenContractConfig,
+    functionName: "allowance",
+    args: [account?.address, config?.Bridge?.address],
+    scopeKey: "allowance",
+  });
+
+  const formatAllowance = useMemo(() => {
+    if (!allowanceRet) return 0;
+    return formatAssetByDecimal(
+      allowanceRet?.toString(),
+      currentAssetPair?.token?.decimal
     );
+  }, [allowanceRet, currentAssetPair?.token?.decimal]);
 
+  const wagmiConfig = useConfig();
+  const { writeContractAsync } = useWriteContract();
 
-
-    const onDeposit = useCallback(
-        async ({ hashlock, fromAddr, toAddr, tokenAddr, amount, timeLock, fee, toLightning = true, signature = '0x' }, wait = true, reloadAllowance = true) => {
-
-            const contractInfo = await readContract(wagmiConfig, {
-                ...bridgeContractConfig,
-                functionName: "getContractByKey",
-                args: [hashlock],
-            });
-            if (contractInfo?.hashlock === hashlock) {
-                throw new Error('Invoice already exists.');
-            }
-
-            const depositGas = await publicClient.estimateContractGas({
-                ...bridgeContractConfig,
-                functionName: "deposit",
-                args: [hashlock, fromAddr, toAddr, tokenAddr, BigInt(amount), timeLock, fee, toLightning, signature],
-                value: fee,
-                account: account?.address,
-            })
-            console.log('depositGas', depositGas)
-
-
-            const tx = await writeContractAsync({
-                ...bridgeContractConfig,
-                functionName: "deposit",
-                args: [hashlock, fromAddr, toAddr, tokenAddr, BigInt(amount), timeLock, fee, toLightning, signature],
-                value: fee
-            });
-
-            if (wait) {
-                await waitForTransactionReceipt(
-                    wagmiConfig,
-                    {
-                        hash: tx
-                    },
-                    1
-                );
-                if (onReloadAllowance && reloadAllowance) {
-                    await onReloadAllowance();
-                }
-            }
-            return tx;
+  const onApprove = useCallback(
+    async (approveAmount, wait = true) => {
+      //console.log("🚀 ~ onApprove ~ approveAmount:", approveAmount, config?.address)
+      const tx = await writeContractAsync({
+        ...tokenContractConfig,
+        functionName: "approve",
+        args: [config?.Bridge?.address, BigInt(approveAmount)],
+        chainId: chainId,
+      });
+
+      if (wait) {
+        await waitForTransactionReceipt(
+          wagmiConfig,
+          {
+            hash: tx,
+          },
+          1
+        );
+        if (onReloadAllowance) {
+          await onReloadAllowance();
+        }
+      }
+      return tx;
+    },
+    [
+      chainId,
+      config?.Bridge?.address,
+      onReloadAllowance,
+      tokenContractConfig,
+      wagmiConfig,
+      writeContractAsync,
+    ]
+  );
+
+  const onDeposit = useCallback(
+    async (
+      {
+        hashlock,
+        nodePubkey,
+        fromAddr,
+        toAddr,
+        pairId,
+        amount,
+        timeLock,
+        fee,
+        toLightning = true,
+        signature = "0x",
+      },
+    ) => {
+      const contractInfo = await readContract(wagmiConfig, {
+        ...bridgeContractConfig,
+        functionName: "getContractByKey",
+        args: [hashlock],
+      });
+      if (contractInfo?.hashlock === hashlock) {
+        throw new Error("Invoice already exists.");
+      }
+      const args = [
+        hashlock,
+        toBytes32(nodePubkey),
+        fromAddr,
+        toAddr,
+        pairId,
+        BigInt(amount),
+        timeLock,
+        fee,
+        toLightning,
+        signature,
+      ];
+      const depositGas = await publicClient.estimateContractGas({
+        ...bridgeContractConfig,
+        functionName: "deposit",
+        args: args,
+        value: fee,
+        account: account?.address,
+      });
+
+      const gasLimit = BigInt(Math.floor(Number(depositGas) * 1.2));
+      const tx = await writeContractAsync({
+        ...bridgeContractConfig,
+        functionName: "deposit",
+        args: args,
+        value: fee,
+        chainId: chainId,
+        gas: gasLimit,
+      });
+      console.log(`🚀 ~ onDeposit ~ tx: ${tx}, will wait for 1 confirm`);
+      await waitForTransactionReceipt(
+        wagmiConfig,
+        {
+          hash: tx,
         },
-        [bridgeContractConfig, onReloadAllowance, wagmiConfig, writeContractAsync]
-    );
-
-    return {
-        allowanceRet,
-        formatAllowance,
-        allowanceLoading,
-        onReloadAllowance,
-        onApprove,
-        onDeposit
-    };
+        1
+      );
+      
+    //   if (onReloadAllowance && reloadAllowance) {
+    //      onReloadAllowance();
+    //   }
+      //}
+      return tx;
+    },
+    [chainId, account?.address, bridgeContractConfig, publicClient, wagmiConfig, writeContractAsync]
+  );
+
+  return {
+    allowanceRet,
+    formatAllowance,
+    allowanceLoading,
+    onReloadAllowance,
+    onApprove,
+    onDeposit,
+  };
 }

package/src/hooks/useGetMinAndMax.js

@@ -0,0 +1,48 @@
+import { useMemo } from "react";
+import { balanceToFixed } from "../constants";
+import useStore from "../store";
+export const useGetMinAndMax = (payDirection,reserveInfo) => {
+  const { currentAssetPair } = useStore();
+//   console.log("🚀 ~ useGetMinAndMax ~ currentAssetPair:",reserveInfo )
+  const fixedLocalChannelBalance = useMemo(() => {
+    if (reserveInfo) {
+      return balanceToFixed(reserveInfo.maxAsset, currentAssetPair?.asset?.decimal);
+    }
+    return 0;
+  }, [currentAssetPair?.asset?.decimal, reserveInfo]);
+
+
+  const fixedRemoteChannelBalance = useMemo(()=>{
+    if(reserveInfo){
+        return balanceToFixed(reserveInfo?.remoteAssetbalance, currentAssetPair?.asset?.decimal);
+    }
+    return 0;
+  },[currentAssetPair?.asset?.decimal, reserveInfo])
+
+
+  const max = useMemo(()=>{
+    if(payDirection==="evmToLightning"){
+        const value = Math.min(reserveInfo?.max, Number(fixedLocalChannelBalance));
+        return value
+    }else{
+        const lspBalance = balanceToFixed(reserveInfo?.maxToken, currentAssetPair?.token?.decimal);
+        const value = Math.min(reserveInfo?.max, Number(fixedRemoteChannelBalance), Number(lspBalance));
+        return value
+    }
+   },[currentAssetPair?.token?.decimal, fixedLocalChannelBalance, fixedRemoteChannelBalance, payDirection, reserveInfo?.max, reserveInfo?.maxToken])
+   
+   const min = useMemo(()=>{
+        return Number(max)<Number(reserveInfo?.min)? Number(max): Number(reserveInfo?.min)
+   },[reserveInfo?.min,max])
+
+
+   
+
+   const unitName = useMemo(()=>{
+    if(payDirection==="evmToLightning"){
+        return currentAssetPair?.token?.name;
+    }
+    return currentAssetPair?.asset?.name;
+   },[currentAssetPair, payDirection])
+  return { min, max, unitName };
+};

package/src/hooks/useLspApi.js

@@ -1,53 +1,70 @@
 import { useRequest } from "ahooks";
 import { useEffect, useMemo } from "react";
-import { getPairs, getReserveInfo } from "../apis/lspApi";
+import { getPairs, getReserveInfo, getContractConfig } from "../apis/lspApi";
 import useStore from "../store";
 export const useGetPairs = () => {
-    const { setCurrentAssetPair, setAllAssetPairs, targetNetwork, astraApiUrl } = useStore();
-    const { data, run, loading, refresh, cancel } = useRequest(() => getPairs({ chainId: targetNetwork?.id }), {
-        refreshDeps: [targetNetwork?.id, astraApiUrl],
-        ready: !!targetNetwork?.id && !!astraApiUrl
-    });
+  const { setCurrentAssetPair, setAllAssetPairs, targetNetwork, astraApiUrl } =
+    useStore();
+  const { data, run, loading, refresh, cancel } = useRequest(
+    () => getPairs({ chainId: targetNetwork?.id }),
+    {
+      refreshDeps: [targetNetwork?.id, astraApiUrl],
+      ready: !!targetNetwork?.id && !!astraApiUrl,
+    }
+  );
 
-    useEffect(() => {
-        if (data?.data?.pairs) {
-            setAllAssetPairs(data?.data?.pairs);
-            //setCurrentAssetPair(data?.data?.pairs[0]);
-        }
-    }, [data?.data?.pairs, setAllAssetPairs, setCurrentAssetPair])
+  useEffect(() => {
+    if (data?.data?.pairs) {
+      setAllAssetPairs(data?.data?.pairs);
+      //setCurrentAssetPair(data?.data?.pairs[0]);
+    }
+  }, [data?.data?.pairs, setAllAssetPairs, setCurrentAssetPair]);
 
-    return {
-        summary: data?.data || null,
-        loading,
-        run,
-        refresh,
-        cancel
-    };
+  return {
+    summary: data?.data || null,
+    loading,
+    run,
+    refresh,
+    cancel,
+  };
 };
 
 export const useGetReserveInfo = (targetNetwork, currentAssetPair) => {
-
-    const assetId = useMemo(() => {
+  /*   const assetId = useMemo(() => {
         return currentAssetPair?.asset?.assetId
-    }, [currentAssetPair?.asset?.assetId])
-    const chainId = useMemo(() => {
-        return targetNetwork?.id
-    }, [targetNetwork?.id])
+    }, [currentAssetPair?.asset?.assetId]) */
+  const chainId = useMemo(() => {
+    return targetNetwork?.id;
+  }, [targetNetwork?.id]);
 
-    const pairName = useMemo(() => {
-        return currentAssetPair?.pairName
-    }, [currentAssetPair])
+  const pairId = useMemo(() => {
+    return currentAssetPair?.pairId;
+  }, [currentAssetPair]);
 
+  const { data, loading, refresh } = useRequest(
+    () => getReserveInfo({ chainId: chainId, pairId: pairId }),
+    {
+      refreshDeps: [chainId, pairId],
+      ready: !!chainId && !!pairId,
+      debounceWait: 300,
+    }
+  );
 
-    const { data, loading, refresh } = useRequest(() => getReserveInfo({ chainId: chainId, assetId: assetId, pairName: pairName }), {
-        refreshDeps: [assetId, chainId, pairName],
-        ready: !!chainId && !!assetId && !!pairName,
-        debounceWait: 300,
-    });
+  return {
+    reserveInfo: data?.data,
+    loading,
+    refresh,
+  };
+};
+export const useGetContractConfig = () => {
+  const { data, loading, refresh } = useRequest(() => getContractConfig(), {
+    refreshDeps: [],
+    ready: true,
+  });
 
-    return {
-        reserveInfo: data?.data,
-        loading,
-        refresh
-    }
-}
+  return {
+    contractConfig: data?.data,
+    loading,
+    refresh,
+  };
+};

package/src/hooks/useParseInvoice.js

@@ -1,85 +1,95 @@
 import { useCallback, useMemo, useState } from "react";
-import "../lib/bolt11.min.js"
+import "../lib/bolt11.min.js";
 import useStore from "../store";
-import { msatsToTprAsset } from "../utils";
+import { invoiceToAssetInfo } from "../utils";
 // import { useEffect } from "react";
 import Decimal from "decimal.js";
 import { useDebounceEffect } from "ahooks";
 // window.decode = decode;
 function getPaymentHash(requestObject) {
-    // go through the tags and find the 'payment_hash' tagName and return the 'data'
-    const paymentHash = requestObject.tags.find(tag => tag.tagName === "payment_hash");
-    if (!paymentHash) {
-        return undefined;
-    }
-    return "0x" + paymentHash.data.toString();
+  // go through the tags and find the 'payment_hash' tagName and return the 'data'
+  const paymentHash = requestObject.tags.find(
+    (tag) => tag.tagName === "payment_hash"
+  );
+  if (!paymentHash) {
+    return undefined;
+  }
+  return "0x" + paymentHash.data.toString();
 }
 export default function useParseInvoice(invoice) {
-    const [assetAmt, setAssetAmt] = useState(0);
-    const [hashlock, setHashlock] = useState("");
-    const { currentAssetPair } = useStore();
-    const [parseInvoiceLoading, setParseInvoiceLoading] = useState(false);
-    const formatAssetAmt = useMemo(() => {
-        if (assetAmt && currentAssetPair) {
-            const decimal = currentAssetPair.asset.decimal;
-            return new Decimal(assetAmt).div(10 ** decimal).toFixed(decimal);
-        }
-        return 0;
-    }, [assetAmt, currentAssetPair])
-
-    const tokenAmt = useMemo(() => {
-        if (currentAssetPair) {
-            const decimal = currentAssetPair.token.decimal;
-            return new Decimal(formatAssetAmt).mul(10 ** decimal).toFixed(0);
-        }
-        return 0;
-    }, [currentAssetPair, formatAssetAmt])
-
-    const formatTokenAmt = useMemo(() => {
-        if (currentAssetPair) {
-            const decimal = currentAssetPair.token.decimal;
-            return new Decimal(tokenAmt).div(10 ** decimal).toFixed(decimal);
-        }
-        return 0;
-
-    }, [currentAssetPair, tokenAmt])
-
-
-    const parseInvoice = useCallback(async () => {
-        try {
-            setParseInvoiceLoading(true)
-            const decoded = window.lightningPayReq.decode(invoice);
-            const numMsat = decoded.millisatoshis;
-            const amt = await msatsToTprAsset(numMsat, currentAssetPair.asset.assetId);
-            setAssetAmt(amt);
-            const hashlock = getPaymentHash(decoded);
-            setHashlock(hashlock);
-
-        } catch (e) {
-            console.log(e.message)
-            setAssetAmt(0);
-        } finally {
-            setParseInvoiceLoading(false)
-        }
-
-
-    }, [currentAssetPair, invoice])
-    useDebounceEffect(() => {
-        if (invoice && currentAssetPair) {
-            parseInvoice();
-        }
+  const [assetAmt, setAssetAmt] = useState(0);
+  const [hashlock, setHashlock] = useState("");
+  const { currentAssetPair } = useStore();
+  const [isExpired, setIsExpired] = useState(false);
+  const [parseInvoiceLoading, setParseInvoiceLoading] = useState(false);
+  const formatAssetAmt = useMemo(() => {
+    if (assetAmt && currentAssetPair) {
+      const decimal = currentAssetPair.asset.decimal;
+      return new Decimal(assetAmt).div(10 ** decimal).toFixed(decimal);
+    }
+    return 0;
+  }, [assetAmt, currentAssetPair]);
 
-    }, [currentAssetPair, invoice, parseInvoice], {
-        wait: 500
-    })
+  const tokenAmt = useMemo(() => {
+    if (currentAssetPair) {
+      const decimal = currentAssetPair.token.decimal;
+      return new Decimal(formatAssetAmt).mul(10 ** decimal).toFixed(0);
+    }
+    return 0;
+  }, [currentAssetPair, formatAssetAmt]);
 
+  const formatTokenAmt = useMemo(() => {
+    if (currentAssetPair) {
+      const decimal = currentAssetPair.token.decimal;
+      const displayDecimal = currentAssetPair.asset.decimal;
+      return new Decimal(tokenAmt)
+        .div(10 ** decimal)
+        .toFixed(displayDecimal, Decimal.ROUND_DOWN);
+    }
+    return 0;
+  }, [currentAssetPair, tokenAmt]);
 
-    return {
-        assetAmt,
-        formatAssetAmt,
-        tokenAmt,
-        formatTokenAmt,
-        hashlock,
-        parseInvoiceLoading
+  const parseInvoice = useCallback(async () => {
+    try {
+      setParseInvoiceLoading(true);
+      const decoded = window.lightningPayReq.decode(invoice);
+      if (decoded.timeExpireDate < Math.floor(Date.now() / 1000)) {
+        setIsExpired(true);
+      }
+      //const numMsat = decoded.millisatoshis;
+      const { amount: amt } = await invoiceToAssetInfo({
+        payReq: invoice,
+        assetId: currentAssetPair.asset.assetId,
+      });
+      setAssetAmt(amt);
+      const hashlock = getPaymentHash(decoded);
+      setHashlock(hashlock);
+    } catch (e) {
+      console.log(e.message);
+      setAssetAmt(0);
+    } finally {
+      setParseInvoiceLoading(false);
     }
-}
+  }, [currentAssetPair, invoice]);
+  useDebounceEffect(
+    () => {
+      if (invoice && currentAssetPair) {
+        parseInvoice();
+      }
+    },
+    [currentAssetPair, invoice, parseInvoice],
+    {
+      wait: 500,
+    }
+  );
+
+  return {
+    assetAmt,
+    formatAssetAmt,
+    tokenAmt,
+    formatTokenAmt,
+    hashlock,
+    parseInvoiceLoading,
+    isExpired,
+  };
+}