@compilot/react-sdk 2.3.9-dev → 2.3.10-dev

package/dist/compilot-react-sdk.cjs.dev.js

@@ -744,223 +744,6 @@ var useAsyncMutationState = function useAsyncMutationState(_ref) {
   return _objectSpread2(_objectSpread2({}, globalState), {}, _defineProperty(_defineProperty(_defineProperty({}, mutationName, mutateAsync), "setData", setData), "setPending", setPending));
 };
 
-/**
- * A hook that returns a function that opens the ComPilot ID widget.
- *
- * @param loginParams - The login parameters to use when opening the widget.
- * @returns The async mutation state of the widget opening.
- *
- * @category Hook
- */
-var useOpenWidget = function useOpenWidget(loginParams) {
-  var config = useComPilotConfig();
-  var mutationFn = react.useCallback(function () {
-    return webSdk.openWidget(config, loginParams);
-  }, [config]);
-  var mutationState = useAsyncMutationState({
-    mutationName: "openWidget",
-    mutationKey: ["openWidget", config._internal.identifier],
-    mutationFn: mutationFn,
-    defaultValue: webSdk.isOpen(config)
-  });
-  react.useEffect(function () {
-    var unsubscribe = webSdk.watchWidgetVisibleState(config, {
-      onChange: function onChange(isVisible) {
-        mutationState.setData(isVisible);
-      },
-      onIsLoadingChange: mutationState.setPending
-    });
-    return unsubscribe;
-  }, [config, mutationState.setData, mutationState.setPending]);
-  return mutationState;
-};
-
-/**
- * A callback that returns a transaction authorization data signature.
- *
- * @category Callback
- */
-
-/**
- * A hook that returns a function that returns a transaction authorization data signature.
- *
- * @returns A function that returns a transaction authorization data signature.
- *
- * @category Hook
- *
- * @example
- *
- * ##### EIP-155 Transaction Wagmi Example
- *
- * ```tsx
- * import { useGetTxAuthDataSignature } from "@compilot/react-sdk";
- * import { waitForTransactionReceipt } from "viem/actions";
- * import { encodeFunctionData } from "viem";
- * import { usePublicClient, useWalletClient } from "wagmi";
- *
- * const MyComponent = () => {
- *
- *  const { getTxAuthDataSignature } = useGetTxAuthDataSignature();
- *  const walletClient = useWalletClient();
- *  const publicClient = usePublicClient();
- *
- *  const gatedNftMint = async () => {
- *
- *   // Get signature for the given parameters
- *   const signatureResponse = await getTxAuthDataSignature({
- *     namespace: "eip155",
- *     contractAbi,
- *     contractAddress,
- *     functionName: "mintNFTGated",
- *     args: [account.address],
- *     userAddress: account.address,
- *     chainId: EvmChainId.parse(chainId),
- *   });
- *
- *   if (!signatureResponse.isAuthorized) {
- *     throw new Error("User is not authorized");
- *   }
- *
- *   // Mint Gated Nft with signature
- *   const unsignedTx = encodeFunctionData({
- *     abi: contractAbi,
- *     functionName: "mintNFTGated",
- *     args: [account.address],
- *   });
- *
- *   // Build the raw transaction data with the signature
- *   const txData = (unsignedTx + signatureResponse.payload) as `0x${string}`;
- *
- *   // try to mint nft
- *   const tx = await walletClient.data.sendTransaction({
- *     to: contractAddress,
- *     data: txData,
- *   });
- *
- *   const receipt = await waitForTransactionReceipt(publicClient, {
- *     hash: tx,
- *   });
- *
- *   return receipt;
- *  };
- *
- *  return <button onClick={gatedNftMint}>Mint Gated NFT</button>;
- * };
- * ```
- *
- * ### Tezos Transaction Example
- *
- * ```tsx
- * import { useGetTxAuthDataSignature } from "@compilot/react-sdk";
- * import { packDataBytes, Parser } from "@taquito/michel-codec";
- * import type { MichelsonData, MichelsonType } from "@taquito/michel-codec";
- * import { RpcClient } from "@taquito/rpc";
- *
- * const MyComponent = () => {
- *  const { getTxAuthDataSignature } = useGetTxAuthDataSignature();
- *  const wallet = useWallet();
- *
- *  const signAndSend = async () => {
- *
- *   // prepare the mint function call
- *   const storage: any = await claimerContract.storage();
- *   const lastAssetId = storage.siggated_extension.extension.lastMinted.toNumber() as number;
- *   const functionCallArgs = {
- *     owner: userAddress,
- *     token_id: (lastAssetId + 1).toString(), //"1",
- *   };
- *   const functionCallArgsBytes = convertMint(
- *     functionCallArgs.owner,
- *     functionCallArgs.token_id,
- *   );
- *
- *   // Get signature for the given parameters
- *   const signatureResponse = await getTxAuthDataSignature({
- *    namespace: "tezos",
- *    contractAddress: "KT1JN7a2es4Ne8SuePZU7YrHKG49hfgCCyBK",
- *    functionName: "%mint_gated%",
- *    args: functionCallArgsBytes,
- *    chainID: TezosChainId.parse(currentChainId),
- *    userAddress: userAddress as TezosImplicitAddress,
- *   });
- *
- *   // Check if the user is authorized
- *   if (!signatureResponse.isAuthorized) {
- *     return {
- *       signatureResponse: {
- *         isAuthorized: false,
- *         signature: "None",
- *       },
- *     };
- *   }
- *
- *   // Mint Gated Nft with signature
- *   const op = await claimerContract.methodsObject
- *    .mint_gated({
- *      userAddress,
- *      expirationBlock: signatureResponse.blockExpiration,
- *      functionName,
- *      functionArgs: functionCallArgsBytes,
- *      signerPublicKey: COMPILOT_SIGNER_PK,
- *      signature: signatureResponse.signature,
- *    })
- *    .send();
- *   await op.confirmation(2);
- *  };
- *  return <button onClick={signAndSend}>Sign and Send</button>;
- * };
- *
- *
- * // Helper function to convert mint function to bytes
- * function convertMint(owner_str: string, token_id: string) {
- *  const data = `(Pair "${owner_str}" ${token_id})`;
- *  const type = `(pair address nat)`;
- *  const p = new Parser();
- *  const dataJSON = p.parseMichelineExpression(data);
- *  const typeJSON = p.parseMichelineExpression(type);
- *  const packed = packDataBytes(
- *    dataJSON as MichelsonData,
- *    typeJSON as MichelsonType,
- *  );
- *  return packed.bytes;
- * }
- *
- * // Tezos signer public key
- * const COMPILOT_SIGNER_PK = "edpkurPsQ8eUApnLUJ9ZPDvu98E8VNj4KtJa1aZr16Cr5ow5VHKnz4";
- * const client = new RpcClient("https://rpc.ghostnet.teztnets.com/");
- * ```
- *
- */
-var useGetTxAuthDataSignature = function useGetTxAuthDataSignature() {
-  var config = useComPilotConfig();
-  var mutationFn = react.useCallback(/*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(params) {
-      var res;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return webSdk.getTxAuthDataSignature(config, params);
-          case 2:
-            res = _context.sent;
-            return _context.abrupt("return", res);
-          case 4:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    }));
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }(), [config._internal.widgetStateStore, config._internal.identifier]);
-  return useAsyncMutationState({
-    mutationName: "getTxAuthDataSignature",
-    mutationKey: ["getTxAuthDataSignature", config._internal.identifier],
-    mutationFn: mutationFn
-  });
-};
-
 /**
  * A hook that returns a function that authenticates the user without opening the ComPilot ID widget.
  * This will authenticate the user only if they are not already authenticated.
@@ -1232,12 +1015,296 @@ var useDisconnect = function useDisconnect() {
   });
 };
 
+/**
+ * A callback that returns a transaction authorization data signature.
+ *
+ * @category Callback
+ */
+
+/**
+ * A hook that returns a function that returns a transaction authorization data signature.
+ *
+ * @returns A function that returns a transaction authorization data signature.
+ *
+ * @category Hook
+ *
+ * @example
+ *
+ * ##### EIP-155 Transaction Wagmi Example
+ *
+ * ```tsx
+ * import { useGetTxAuthDataSignature } from "@compilot/react-sdk";
+ * import { waitForTransactionReceipt } from "viem/actions";
+ * import { encodeFunctionData } from "viem";
+ * import { usePublicClient, useWalletClient } from "wagmi";
+ *
+ * const MyComponent = () => {
+ *
+ *  const { getTxAuthDataSignature } = useGetTxAuthDataSignature();
+ *  const walletClient = useWalletClient();
+ *  const publicClient = usePublicClient();
+ *
+ *  const gatedNftMint = async () => {
+ *
+ *   // Get signature for the given parameters
+ *   const signatureResponse = await getTxAuthDataSignature({
+ *     namespace: "eip155",
+ *     contractAbi,
+ *     contractAddress,
+ *     functionName: "mintNFTGated",
+ *     args: [account.address],
+ *     userAddress: account.address,
+ *     chainId: EvmChainId.parse(chainId),
+ *   });
+ *
+ *   if (!signatureResponse.isAuthorized) {
+ *     throw new Error("User is not authorized");
+ *   }
+ *
+ *   // Mint Gated Nft with signature
+ *   const unsignedTx = encodeFunctionData({
+ *     abi: contractAbi,
+ *     functionName: "mintNFTGated",
+ *     args: [account.address],
+ *   });
+ *
+ *   // Build the raw transaction data with the signature
+ *   const txData = (unsignedTx + signatureResponse.payload) as `0x${string}`;
+ *
+ *   // try to mint nft
+ *   const tx = await walletClient.data.sendTransaction({
+ *     to: contractAddress,
+ *     data: txData,
+ *   });
+ *
+ *   const receipt = await waitForTransactionReceipt(publicClient, {
+ *     hash: tx,
+ *   });
+ *
+ *   return receipt;
+ *  };
+ *
+ *  return <button onClick={gatedNftMint}>Mint Gated NFT</button>;
+ * };
+ * ```
+ *
+ * ### Tezos Transaction Example
+ *
+ * ```tsx
+ * import { useGetTxAuthDataSignature } from "@compilot/react-sdk";
+ * import { packDataBytes, Parser } from "@taquito/michel-codec";
+ * import type { MichelsonData, MichelsonType } from "@taquito/michel-codec";
+ * import { RpcClient } from "@taquito/rpc";
+ *
+ * const MyComponent = () => {
+ *  const { getTxAuthDataSignature } = useGetTxAuthDataSignature();
+ *  const wallet = useWallet();
+ *
+ *  const signAndSend = async () => {
+ *
+ *   // prepare the mint function call
+ *   const storage: any = await claimerContract.storage();
+ *   const lastAssetId = storage.siggated_extension.extension.lastMinted.toNumber() as number;
+ *   const functionCallArgs = {
+ *     owner: userAddress,
+ *     token_id: (lastAssetId + 1).toString(), //"1",
+ *   };
+ *   const functionCallArgsBytes = convertMint(
+ *     functionCallArgs.owner,
+ *     functionCallArgs.token_id,
+ *   );
+ *
+ *   // Get signature for the given parameters
+ *   const signatureResponse = await getTxAuthDataSignature({
+ *    namespace: "tezos",
+ *    contractAddress: "KT1JN7a2es4Ne8SuePZU7YrHKG49hfgCCyBK",
+ *    functionName: "%mint_gated%",
+ *    args: functionCallArgsBytes,
+ *    chainID: TezosChainId.parse(currentChainId),
+ *    userAddress: userAddress as TezosImplicitAddress,
+ *   });
+ *
+ *   // Check if the user is authorized
+ *   if (!signatureResponse.isAuthorized) {
+ *     return {
+ *       signatureResponse: {
+ *         isAuthorized: false,
+ *         signature: "None",
+ *       },
+ *     };
+ *   }
+ *
+ *   // Mint Gated Nft with signature
+ *   const op = await claimerContract.methodsObject
+ *    .mint_gated({
+ *      userAddress,
+ *      expirationBlock: signatureResponse.blockExpiration,
+ *      functionName,
+ *      functionArgs: functionCallArgsBytes,
+ *      signerPublicKey: COMPILOT_SIGNER_PK,
+ *      signature: signatureResponse.signature,
+ *    })
+ *    .send();
+ *   await op.confirmation(2);
+ *  };
+ *  return <button onClick={signAndSend}>Sign and Send</button>;
+ * };
+ *
+ *
+ * // Helper function to convert mint function to bytes
+ * function convertMint(owner_str: string, token_id: string) {
+ *  const data = `(Pair "${owner_str}" ${token_id})`;
+ *  const type = `(pair address nat)`;
+ *  const p = new Parser();
+ *  const dataJSON = p.parseMichelineExpression(data);
+ *  const typeJSON = p.parseMichelineExpression(type);
+ *  const packed = packDataBytes(
+ *    dataJSON as MichelsonData,
+ *    typeJSON as MichelsonType,
+ *  );
+ *  return packed.bytes;
+ * }
+ *
+ * // Tezos signer public key
+ * const COMPILOT_SIGNER_PK = "edpkurPsQ8eUApnLUJ9ZPDvu98E8VNj4KtJa1aZr16Cr5ow5VHKnz4";
+ * const client = new RpcClient("https://rpc.ghostnet.teztnets.com/");
+ * ```
+ *
+ */
+var useGetTxAuthDataSignature = function useGetTxAuthDataSignature() {
+  var config = useComPilotConfig();
+  var mutationFn = react.useCallback(/*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(params) {
+      var res;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return webSdk.getTxAuthDataSignature(config, params);
+          case 2:
+            res = _context.sent;
+            return _context.abrupt("return", res);
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }(), [config._internal.widgetStateStore, config._internal.identifier]);
+  return useAsyncMutationState({
+    mutationName: "getTxAuthDataSignature",
+    mutationKey: ["getTxAuthDataSignature", config._internal.identifier],
+    mutationFn: mutationFn
+  });
+};
+
+/**
+ * A hook that returns the current identity wallets.
+ */
+var useIdentityWallets = function useIdentityWallets() {
+  var config = useComPilotConfig();
+  var auth = config._internal.widgetStateStore.select(function (state) {
+    return state.auth;
+  });
+  var _useState = react.useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    queryCacheBuster = _useState2[0],
+    setQueryCacheBuster = _useState2[1];
+  var _useAsyncQueryState = useAsyncQueryState({
+      queryKey: ["useIdentityWallets", config._internal.identifier, auth === "loading" || auth === "not_authenticated" ? "" : auth.token],
+      defaultValue: null
+    }),
+    state = _useAsyncQueryState.state,
+    setError = _useAsyncQueryState.setError,
+    setResult = _useAsyncQueryState.setResult,
+    startLoading = _useAsyncQueryState.startLoading;
+  react.useEffect(function () {
+    if (!config) {
+      return;
+    }
+    startLoading();
+    webSdk.getIdentityWallets(config).then(function (wallets) {
+      setResult(wallets);
+    })["catch"](function (err) {
+      config._internal.logger.error("Failed to fetch identity wallets", err);
+      setError(err instanceof Error ? err : new Error("Unknown error"));
+    });
+  }, [config, queryCacheBuster]);
+  var mutationFn = react.useCallback(/*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(wallet) {
+      var res;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            res = webSdk.attachWalletToIdentity(config, {
+              wallet: wallet
+            });
+            setQueryCacheBuster(function (prev) {
+              return prev + 1;
+            });
+            return _context.abrupt("return", res);
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }(), [config]);
+  var addWalletMutation = useAsyncMutationState({
+    mutationName: "attachWalletToIdentity",
+    mutationKey: ["attachWalletToIdentity", config._internal.identifier, auth === "loading" || auth === "not_authenticated" ? "" : auth.token],
+    mutationFn: mutationFn
+  });
+  return {
+    identityWallets: state,
+    addWalletMutation: addWalletMutation
+  };
+};
+
+/**
+ * A hook that returns a function that opens the ComPilot ID widget.
+ *
+ * @param loginParams - The login parameters to use when opening the widget.
+ * @returns The async mutation state of the widget opening.
+ *
+ * @category Hook
+ */
+var useOpenWidget = function useOpenWidget(loginParams) {
+  var config = useComPilotConfig();
+  var mutationFn = react.useCallback(function () {
+    return webSdk.openWidget(config, loginParams);
+  }, [config]);
+  var mutationState = useAsyncMutationState({
+    mutationName: "openWidget",
+    mutationKey: ["openWidget", config._internal.identifier],
+    mutationFn: mutationFn,
+    defaultValue: webSdk.isOpen(config)
+  });
+  react.useEffect(function () {
+    var unsubscribe = webSdk.watchWidgetVisibleState(config, {
+      onChange: function onChange(isVisible) {
+        mutationState.setData(isVisible);
+      },
+      onIsLoadingChange: mutationState.setPending
+    });
+    return unsubscribe;
+  }, [config, mutationState.setData, mutationState.setPending]);
+  return mutationState;
+};
+
 exports.ComPilotProvider = ComPilotProvider;
 exports.useAuthenticate = useAuthenticate;
 exports.useComPilotConfig = useComPilotConfig;
 exports.useCustomerStatus = useCustomerStatus;
 exports.useDisconnect = useDisconnect;
 exports.useGetTxAuthDataSignature = useGetTxAuthDataSignature;
+exports.useIdentityWallets = useIdentityWallets;
 exports.useOpenWidget = useOpenWidget;
 Object.keys(webSdk).forEach(function (k) {
   if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {