@multiversx/sdk-dapp-liquidity 0.2.0-alpha.1

package/types/rate.mjs

@@ -0,0 +1 @@
+

package/types/token.d.ts

@@ -0,0 +1,12 @@
+import { TokenDTO } from 'dto/Token.dto';
+
+export type TokenType = TokenDTO & {
+    balance?: string;
+};
+export type MvxTokenType = {
+    identifier: string;
+    ticker?: string;
+    name: string;
+    balance?: string;
+    decimals?: number;
+};

package/types/token.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+"use strict";

package/types/token.mjs

@@ -0,0 +1 @@
+

package/types/transaction.d.ts

@@ -0,0 +1,14 @@
+import { TransactionBase, Transaction as ViemTransaction } from 'viem/types/transaction';
+
+export type ServerTransaction = {
+    to: `0x${string}`;
+    data: `0x${string}`;
+    gasLimit: bigint;
+    value: bigint;
+    account: string;
+    txHash: string;
+};
+export type TransactionType = TransactionBase & {
+    account: `0x${string}`;
+};
+export type Transaction = ViemTransaction;

package/types/transaction.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+"use strict";

package/types/transaction.mjs

@@ -0,0 +1 @@
+

package/useBalances-Bxtc4GNK.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+"use strict";
+const require$$0 = require("react");
+const reactjs_context_useWeb3App = require("./reactjs/context/useWeb3App.js");
+const viem = require("viem");
+const actions = require("viem/actions");
+function getAction(client, actionFn, name) {
+  const action_implicit = client[actionFn.name];
+  if (typeof action_implicit === "function")
+    return action_implicit;
+  const action_explicit = client[name];
+  if (typeof action_explicit === "function")
+    return action_explicit;
+  return (params) => actionFn(client, params);
+}
+function getUnit(unit) {
+  if (typeof unit === "number")
+    return unit;
+  if (unit === "wei")
+    return 0;
+  return Math.abs(viem.weiUnits[unit]);
+}
+async function multicall(config, parameters) {
+  const { allowFailure = true, chainId, contracts, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, actions.multicall, "multicall");
+  return action({
+    allowFailure,
+    contracts,
+    ...rest
+  });
+}
+function readContract(config, parameters) {
+  const { chainId, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, actions.readContract, "readContract");
+  return action(rest);
+}
+async function readContracts(config, parameters) {
+  var _a;
+  const { allowFailure = true, blockNumber, blockTag, ...rest } = parameters;
+  const contracts = parameters.contracts;
+  try {
+    const contractsByChainId = {};
+    for (const [index, contract] of contracts.entries()) {
+      const chainId = contract.chainId ?? config.state.chainId;
+      if (!contractsByChainId[chainId])
+        contractsByChainId[chainId] = [];
+      (_a = contractsByChainId[chainId]) == null ? void 0 : _a.push({ contract, index });
+    }
+    const promises = () => Object.entries(contractsByChainId).map(([chainId, contracts2]) => multicall(config, {
+      ...rest,
+      allowFailure,
+      blockNumber,
+      blockTag,
+      chainId: Number.parseInt(chainId),
+      contracts: contracts2.map(({ contract }) => contract)
+    }));
+    const multicallResults = (await Promise.all(promises())).flat();
+    const resultIndexes = Object.values(contractsByChainId).flatMap((contracts2) => contracts2.map(({ index }) => index));
+    return multicallResults.reduce((results, result, index) => {
+      if (results)
+        results[resultIndexes[index]] = result;
+      return results;
+    }, []);
+  } catch (error) {
+    if (error instanceof viem.ContractFunctionExecutionError)
+      throw error;
+    const promises = () => contracts.map((contract) => readContract(config, { ...contract, blockNumber, blockTag }));
+    if (allowFailure)
+      return (await Promise.allSettled(promises())).map((result) => {
+        if (result.status === "fulfilled")
+          return { result: result.value, status: "success" };
+        return { error: result.reason, result: void 0, status: "failure" };
+      });
+    return await Promise.all(promises());
+  }
+}
+async function getBalance(config, parameters) {
+  const { address, blockNumber, blockTag, chainId, token: tokenAddress, unit = "ether" } = parameters;
+  if (tokenAddress) {
+    try {
+      return await getTokenBalance(config, {
+        balanceAddress: address,
+        chainId,
+        symbolType: "string",
+        tokenAddress
+      });
+    } catch (error) {
+      if (error.name === "ContractFunctionExecutionError") {
+        const balance = await getTokenBalance(config, {
+          balanceAddress: address,
+          chainId,
+          symbolType: "bytes32",
+          tokenAddress
+        });
+        const symbol = viem.hexToString(viem.trim(balance.symbol, { dir: "right" }));
+        return { ...balance, symbol };
+      }
+      throw error;
+    }
+  }
+  const client = config.getClient({ chainId });
+  const action = getAction(client, actions.getBalance, "getBalance");
+  const value = await action(blockNumber ? { address, blockNumber } : { address, blockTag });
+  const chain = config.chains.find((x) => x.id === chainId) ?? client.chain;
+  return {
+    decimals: chain.nativeCurrency.decimals,
+    formatted: viem.formatUnits(value, getUnit(unit)),
+    symbol: chain.nativeCurrency.symbol,
+    value
+  };
+}
+async function getTokenBalance(config, parameters) {
+  const { balanceAddress, chainId, symbolType, tokenAddress, unit } = parameters;
+  const contract = {
+    abi: [
+      {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [{ type: "address" }],
+        outputs: [{ type: "uint256" }]
+      },
+      {
+        type: "function",
+        name: "decimals",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: "uint8" }]
+      },
+      {
+        type: "function",
+        name: "symbol",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: symbolType }]
+      }
+    ],
+    address: tokenAddress
+  };
+  const [value, decimals, symbol] = await readContracts(config, {
+    allowFailure: false,
+    contracts: [
+      {
+        ...contract,
+        functionName: "balanceOf",
+        args: [balanceAddress],
+        chainId
+      },
+      { ...contract, functionName: "decimals", chainId },
+      { ...contract, functionName: "symbol", chainId }
+    ]
+  });
+  const formatted = viem.formatUnits(value ?? "0", getUnit(unit ?? decimals));
+  return { decimals, formatted, symbol, value };
+}
+const useBalances = () => {
+  const { config } = reactjs_context_useWeb3App.useWeb3App();
+  const fetchBalances = require$$0.useCallback(
+    async ({
+      address,
+      chainId,
+      tokenIdentifiers
+    }) => {
+      return await Promise.all(
+        tokenIdentifiers.map(async (tokenIdentifier) => {
+          try {
+            const balance = await getBalance(config, {
+              address,
+              chainId: Number(chainId),
+              token: tokenIdentifier
+            });
+            return {
+              tokenId: tokenIdentifier,
+              balance: balance.value.toString()
+            };
+          } catch (error) {
+            console.warn(
+              "Error fetching balance for: ",
+              tokenIdentifier,
+              error
+            );
+            return {
+              tokenId: tokenIdentifier,
+              balance: "0"
+            };
+          }
+        })
+      );
+    },
+    [config]
+  );
+  return {
+    fetchBalances
+  };
+};
+exports.getAction = getAction;
+exports.useBalances = useBalances;

package/useBalances-DA3zEruz.mjs

@@ -0,0 +1,199 @@
+import { useCallback } from "react";
+import { useWeb3App } from "./reactjs/context/useWeb3App.mjs";
+import { weiUnits, ContractFunctionExecutionError, hexToString, trim, formatUnits } from "viem";
+import { multicall as multicall$1, readContract as readContract$1, getBalance as getBalance$1 } from "viem/actions";
+function getAction(client, actionFn, name) {
+  const action_implicit = client[actionFn.name];
+  if (typeof action_implicit === "function")
+    return action_implicit;
+  const action_explicit = client[name];
+  if (typeof action_explicit === "function")
+    return action_explicit;
+  return (params) => actionFn(client, params);
+}
+function getUnit(unit) {
+  if (typeof unit === "number")
+    return unit;
+  if (unit === "wei")
+    return 0;
+  return Math.abs(weiUnits[unit]);
+}
+async function multicall(config, parameters) {
+  const { allowFailure = true, chainId, contracts, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, multicall$1, "multicall");
+  return action({
+    allowFailure,
+    contracts,
+    ...rest
+  });
+}
+function readContract(config, parameters) {
+  const { chainId, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, readContract$1, "readContract");
+  return action(rest);
+}
+async function readContracts(config, parameters) {
+  var _a;
+  const { allowFailure = true, blockNumber, blockTag, ...rest } = parameters;
+  const contracts = parameters.contracts;
+  try {
+    const contractsByChainId = {};
+    for (const [index, contract] of contracts.entries()) {
+      const chainId = contract.chainId ?? config.state.chainId;
+      if (!contractsByChainId[chainId])
+        contractsByChainId[chainId] = [];
+      (_a = contractsByChainId[chainId]) == null ? void 0 : _a.push({ contract, index });
+    }
+    const promises = () => Object.entries(contractsByChainId).map(([chainId, contracts2]) => multicall(config, {
+      ...rest,
+      allowFailure,
+      blockNumber,
+      blockTag,
+      chainId: Number.parseInt(chainId),
+      contracts: contracts2.map(({ contract }) => contract)
+    }));
+    const multicallResults = (await Promise.all(promises())).flat();
+    const resultIndexes = Object.values(contractsByChainId).flatMap((contracts2) => contracts2.map(({ index }) => index));
+    return multicallResults.reduce((results, result, index) => {
+      if (results)
+        results[resultIndexes[index]] = result;
+      return results;
+    }, []);
+  } catch (error) {
+    if (error instanceof ContractFunctionExecutionError)
+      throw error;
+    const promises = () => contracts.map((contract) => readContract(config, { ...contract, blockNumber, blockTag }));
+    if (allowFailure)
+      return (await Promise.allSettled(promises())).map((result) => {
+        if (result.status === "fulfilled")
+          return { result: result.value, status: "success" };
+        return { error: result.reason, result: void 0, status: "failure" };
+      });
+    return await Promise.all(promises());
+  }
+}
+async function getBalance(config, parameters) {
+  const { address, blockNumber, blockTag, chainId, token: tokenAddress, unit = "ether" } = parameters;
+  if (tokenAddress) {
+    try {
+      return await getTokenBalance(config, {
+        balanceAddress: address,
+        chainId,
+        symbolType: "string",
+        tokenAddress
+      });
+    } catch (error) {
+      if (error.name === "ContractFunctionExecutionError") {
+        const balance = await getTokenBalance(config, {
+          balanceAddress: address,
+          chainId,
+          symbolType: "bytes32",
+          tokenAddress
+        });
+        const symbol = hexToString(trim(balance.symbol, { dir: "right" }));
+        return { ...balance, symbol };
+      }
+      throw error;
+    }
+  }
+  const client = config.getClient({ chainId });
+  const action = getAction(client, getBalance$1, "getBalance");
+  const value = await action(blockNumber ? { address, blockNumber } : { address, blockTag });
+  const chain = config.chains.find((x) => x.id === chainId) ?? client.chain;
+  return {
+    decimals: chain.nativeCurrency.decimals,
+    formatted: formatUnits(value, getUnit(unit)),
+    symbol: chain.nativeCurrency.symbol,
+    value
+  };
+}
+async function getTokenBalance(config, parameters) {
+  const { balanceAddress, chainId, symbolType, tokenAddress, unit } = parameters;
+  const contract = {
+    abi: [
+      {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [{ type: "address" }],
+        outputs: [{ type: "uint256" }]
+      },
+      {
+        type: "function",
+        name: "decimals",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: "uint8" }]
+      },
+      {
+        type: "function",
+        name: "symbol",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [{ type: symbolType }]
+      }
+    ],
+    address: tokenAddress
+  };
+  const [value, decimals, symbol] = await readContracts(config, {
+    allowFailure: false,
+    contracts: [
+      {
+        ...contract,
+        functionName: "balanceOf",
+        args: [balanceAddress],
+        chainId
+      },
+      { ...contract, functionName: "decimals", chainId },
+      { ...contract, functionName: "symbol", chainId }
+    ]
+  });
+  const formatted = formatUnits(value ?? "0", getUnit(unit ?? decimals));
+  return { decimals, formatted, symbol, value };
+}
+const useBalances = () => {
+  const { config } = useWeb3App();
+  const fetchBalances = useCallback(
+    async ({
+      address,
+      chainId,
+      tokenIdentifiers
+    }) => {
+      return await Promise.all(
+        tokenIdentifiers.map(async (tokenIdentifier) => {
+          try {
+            const balance = await getBalance(config, {
+              address,
+              chainId: Number(chainId),
+              token: tokenIdentifier
+            });
+            return {
+              tokenId: tokenIdentifier,
+              balance: balance.value.toString()
+            };
+          } catch (error) {
+            console.warn(
+              "Error fetching balance for: ",
+              tokenIdentifier,
+              error
+            );
+            return {
+              tokenId: tokenIdentifier,
+              balance: "0"
+            };
+          }
+        })
+      );
+    },
+    [config]
+  );
+  return {
+    fetchBalances
+  };
+};
+export {
+  getAction as g,
+  useBalances as u
+};