@chipi-stack/chipi-react/dist/index.js

React hooks and components for Chipi SDK

'use strict';

var React = require('react');
var reactQuery = require('@tanstack/react-query');
var backend = require('@chipi-stack/backend');
var jsxRuntime = require('react/jsx-runtime');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var React__default = /*#__PURE__*/_interopDefault(React);

// src/context/ChipiProvider.tsx
var ChipiContext = React.createContext(null);
var createDefaultQueryClient = () => new reactQuery.QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 60 * 1e3,
      // 1 minute
      gcTime: 10 * 60 * 1e3,
      // 10 minutes (formerly cacheTime)
      retry: (failureCount, error) => {
        if (error?.status >= 400 && error?.status < 500) {
          return false;
        }
        return failureCount < 3;
      }
    },
    mutations: {
      retry: false
    }
  }
});
function ChipiProvider({ children, config }) {
  const queryClient = React__default.default.useMemo(() => createDefaultQueryClient(), []);
  const chipiSDK = React__default.default.useMemo(() => new backend.ChipiSDK(config), [config]);
  const value = React__default.default.useMemo(
    () => ({
      chipiSDK,
      config
    }),
    [chipiSDK, config]
  );
  return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsxRuntime.jsx(ChipiContext.Provider, { value, children }) });
}
function useChipiContext() {
  const context = React.useContext(ChipiContext);
  if (!context) {
    throw new Error("useChipiContext must be used within a ChipiProvider");
  }
  return context;
}
function useCreateWallet() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation({
    mutationFn: (input) => chipiSDK.createWallet({
      params: input.params,
      bearerToken: input.bearerToken
    })
  });
  return {
    createWallet: mutation.mutate,
    createWalletAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useGetWallet(input) {
  const { chipiSDK } = useChipiContext();
  const queryClient = reactQuery.useQueryClient();
  const query = reactQuery.useQuery({
    queryKey: ["wallet", input?.params?.externalUserId],
    queryFn: async () => {
      if (!input || !input.params || !input.getBearerToken)
        throw new Error("Input is required");
      const bearerToken = await input.getBearerToken();
      if (!bearerToken) throw new Error("Bearer token is required");
      return chipiSDK.getWallet(input.params, bearerToken);
    },
    enabled: Boolean(
      input?.params?.externalUserId && input?.getBearerToken && input.params.externalUserId.trim() !== ""
    ),
    ...input?.queryOptions
  });
  const fetchWallet = async (newInput) => {
    return queryClient.fetchQuery({
      queryKey: ["wallet", newInput?.params?.externalUserId],
      queryFn: async () => {
        if (!newInput || !newInput.getBearerToken || !newInput.params)
          throw new Error("Input is required");
        const bearerToken = await newInput.getBearerToken();
        if (!bearerToken) throw new Error("Bearer token is required");
        return chipiSDK.getWallet(newInput.params, bearerToken);
      }
    });
  };
  return {
    ...query,
    fetchWallet
  };
}
function useTransfer() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation(
    {
      mutationFn: (input) => chipiSDK.transfer({
        params: {
          ...input.params,
          amount: String(input.params.amount)
        },
        bearerToken: input.bearerToken
      })
    }
  );
  return {
    transfer: mutation.mutate,
    transferAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useApprove() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation({
    mutationFn: (params) => chipiSDK.approve({
      params: {
        ...params.params,
        amount: String(params.params.amount)
      },
      bearerToken: params.bearerToken
    })
  });
  return {
    approve: mutation.mutate,
    approveAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useCreateSkuTransaction() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation({
    mutationFn: (input) => chipiSDK.createSkuTransaction({
      params: input.params,
      bearerToken: input.bearerToken
    })
  });
  return {
    createSkuTransaction: mutation.mutate,
    createSkuTransactionAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useGetSkuTransactionById(input) {
  const { chipiSDK } = useChipiContext();
  const queryClient = reactQuery.useQueryClient();
  const query = reactQuery.useQuery({
    queryKey: ["sku-transaction", input?.id],
    queryFn: async () => {
      if (!input?.id) throw new Error("id is required");
      if (!input?.getBearerToken) throw new Error("getBearerToken is required");
      const bearerToken = await input.getBearerToken();
      if (!bearerToken) throw new Error("Bearer token is required");
      return chipiSDK.skuTransactions.getSkuTransactionById(input.id, bearerToken);
    },
    enabled: Boolean(input?.id && input?.getBearerToken),
    ...input?.queryOptions
  });
  const fetchSkuTransactionById = async (newInput) => {
    return queryClient.fetchQuery({
      queryKey: ["sku-transaction", newInput?.id],
      queryFn: async () => {
        if (!newInput?.id) throw new Error("id is required");
        if (!newInput?.getBearerToken) throw new Error("getBearerToken is required");
        const bearerToken = await newInput.getBearerToken();
        if (!bearerToken) throw new Error("Bearer token is required");
        return chipiSDK.skuTransactions.getSkuTransactionById(newInput.id, bearerToken);
      }
    });
  };
  return {
    ...query,
    fetchSkuTransactionById
  };
}
function useGetSkus(input) {
  const { chipiSDK } = useChipiContext();
  const queryClient = reactQuery.useQueryClient();
  const buildQueryKey = (q) => [
    "available-skus",
    q?.page ?? 1,
    q?.limit ?? 10,
    q?.offset ?? 0,
    q?.provider ?? null,
    q?.category ?? null
  ];
  const query = reactQuery.useQuery({
    queryKey: buildQueryKey(input?.query),
    queryFn: async () => {
      if (!input?.getBearerToken) throw new Error("getBearerToken is required");
      const bearerToken = await input.getBearerToken();
      if (!bearerToken) throw new Error("Bearer token is required");
      return chipiSDK.skus.getSkus(bearerToken, input.query);
    },
    enabled: Boolean(input?.getBearerToken),
    ...input?.queryOptions
  });
  const fetchAvailableSkus = async (newInput) => {
    return queryClient.fetchQuery({
      queryKey: buildQueryKey(newInput?.query),
      queryFn: async () => {
        if (!newInput?.getBearerToken) throw new Error("getBearerToken is required");
        const bearerToken = await newInput.getBearerToken();
        if (!bearerToken) throw new Error("Bearer token is required");
        return chipiSDK.skus.getSkus(bearerToken, newInput.query);
      }
    });
  };
  return {
    ...query,
    fetchAvailableSkus
  };
}
function useStakeVesuUsdc() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation({
    mutationFn: (params) => chipiSDK.stakeVesuUsdc({
      params: {
        ...params.params,
        amount: String(params.params.amount)
      },
      bearerToken: params.bearerToken
    })
  });
  return {
    stakeVesuUsdc: mutation.mutate,
    stakeVesuUsdcAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useWithdrawVesuUsdc() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation({
    mutationFn: (params) => chipiSDK.withdrawVesuUsdc({
      params: {
        ...params.params,
        amount: String(params.params.amount)
      },
      bearerToken: params.bearerToken
    })
  });
  return {
    withdrawVesuUsdc: mutation.mutate,
    withdrawVesuUsdcAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useCallAnyContract() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation({
    mutationFn: (params) => chipiSDK.callAnyContract(params)
  });
  return {
    callAnyContract: mutation.mutate,
    callAnyContractAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useRecordSendTransaction() {
  const { chipiSDK } = useChipiContext();
  const mutation = reactQuery.useMutation({
    mutationFn: (input) => chipiSDK.recordSendTransaction({
      params: input.params,
      bearerToken: input.bearerToken
    })
  });
  return {
    recordSendTransaction: mutation.mutate,
    recordSendTransactionAsync: mutation.mutateAsync,
    data: mutation.data,
    isLoading: mutation.isPending,
    isError: mutation.isError,
    error: mutation.error,
    isSuccess: mutation.isSuccess,
    reset: mutation.reset
  };
}
function useGetTokenBalance(input) {
  const { chipiSDK } = useChipiContext();
  const queryClient = reactQuery.useQueryClient();
  const query = reactQuery.useQuery({
    queryKey: ["chain-token-balance", input?.params?.chainToken, input?.params?.chain, input?.params?.walletPublicKey, input?.params?.externalUserId],
    queryFn: async () => {
      if (!input || !input.params || !input.getBearerToken) throw new Error("Input is required");
      const bearerToken = await input.getBearerToken();
      if (!bearerToken) throw new Error("Bearer token is required");
      return chipiSDK.getTokenBalance(input.params, bearerToken);
    },
    enabled: Boolean(input?.params && input?.getBearerToken),
    ...input?.queryOptions
  });
  const fetchTokenBalance = async (newInput) => {
    return queryClient.fetchQuery({
      queryKey: ["chain-token-balance", newInput?.params?.chainToken, newInput?.params?.chain, newInput?.params?.walletPublicKey, newInput?.params?.externalUserId],
      queryFn: async () => {
        if (!newInput || !newInput.getBearerToken || !newInput.params) throw new Error("Input is required");
        const bearerToken = await newInput.getBearerToken();
        if (!bearerToken) throw new Error("Bearer token is required");
        return chipiSDK.getTokenBalance(newInput.params, bearerToken);
      }
    });
  };
  return {
    ...query,
    fetchTokenBalance
  };
}

exports.ChipiProvider = ChipiProvider;
exports.useApprove = useApprove;
exports.useCallAnyContract = useCallAnyContract;
exports.useChipiContext = useChipiContext;
exports.useCreateSkuTransaction = useCreateSkuTransaction;
exports.useCreateWallet = useCreateWallet;
exports.useGetSkuTransactionById = useGetSkuTransactionById;
exports.useGetSkus = useGetSkus;
exports.useGetTokenBalance = useGetTokenBalance;
exports.useGetWallet = useGetWallet;
exports.useRecordSendTransaction = useRecordSendTransaction;
exports.useStakeVesuUsdc = useStakeVesuUsdc;
exports.useTransfer = useTransfer;
exports.useWithdrawVesuUsdc = useWithdrawVesuUsdc;
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map