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

package/dist/compilot-react-sdk.esm.js

@@ -1,5 +1,5 @@
 import { useEffect, useState, useCallback, useMemo, createContext, useContext } from 'react';
-import { load, openWidget, isOpen, watchWidgetVisibleState, getTxAuthDataSignature, authenticate, isAuthenticated, watchIsAuthenticated, watchCustomerStatus, getCustomerStatus, disconnect } from '@compilot/web-sdk';
+import { load, authenticate, isAuthenticated, watchIsAuthenticated, watchCustomerStatus, getCustomerStatus, disconnect, getTxAuthDataSignature, getIdentityWallets, attachWalletToIdentity, openWidget, isOpen, watchWidgetVisibleState } from '@compilot/web-sdk';
 export * from '@compilot/web-sdk';
 import { jsx, Fragment } from 'react/jsx-runtime';
 
@@ -741,223 +741,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 = useCallback(function () {
-    return openWidget(config, loginParams);
-  }, [config]);
-  var mutationState = useAsyncMutationState({
-    mutationName: "openWidget",
-    mutationKey: ["openWidget", config._internal.identifier],
-    mutationFn: mutationFn,
-    defaultValue: isOpen(config)
-  });
-  useEffect(function () {
-    var unsubscribe = 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 = 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 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.
@@ -1229,4 +1012,287 @@ var useDisconnect = function useDisconnect() {
   });
 };
 
-export { ComPilotProvider, useAuthenticate, useComPilotConfig, useCustomerStatus, useDisconnect, useGetTxAuthDataSignature, useOpenWidget };
+/**
+ * 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 = 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 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 = 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;
+  useEffect(function () {
+    if (!config) {
+      return;
+    }
+    startLoading();
+    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 = 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 = 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 = useCallback(function () {
+    return openWidget(config, loginParams);
+  }, [config]);
+  var mutationState = useAsyncMutationState({
+    mutationName: "openWidget",
+    mutationKey: ["openWidget", config._internal.identifier],
+    mutationFn: mutationFn,
+    defaultValue: isOpen(config)
+  });
+  useEffect(function () {
+    var unsubscribe = watchWidgetVisibleState(config, {
+      onChange: function onChange(isVisible) {
+        mutationState.setData(isVisible);
+      },
+      onIsLoadingChange: mutationState.setPending
+    });
+    return unsubscribe;
+  }, [config, mutationState.setData, mutationState.setPending]);
+  return mutationState;
+};
+
+export { ComPilotProvider, useAuthenticate, useComPilotConfig, useCustomerStatus, useDisconnect, useGetTxAuthDataSignature, useIdentityWallets, useOpenWidget };

package/dist/declarations/src/hooks/index.d.ts

@@ -1,6 +1,7 @@
-export * from "./useOpenWidget.js";
-export * from "./useGetTxAuthDataSignature.js";
 export * from "./useAuthenticate.js";
 export * from "./useCustomerStatus.js";
 export * from "./useDisconnect.js";
+export * from "./useGetTxAuthDataSignature.js";
+export * from "./useIdentityWallets.js";
+export * from "./useOpenWidget.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/declarations/src/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"../../../../src/hooks","sources":["index.ts"],"names":[],"mappings":"AAAA,mCAAgC;AAChC,+CAA4C;AAC5C,qCAAkC;AAClC,uCAAoC;AACpC,mCAAgC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"../../../../src/hooks","sources":["index.ts"],"names":[],"mappings":"AAAA,qCAAkC;AAClC,uCAAoC;AACpC,mCAAgC;AAChC,+CAA4C;AAC5C,wCAAqC;AACrC,mCAAgC"}

package/dist/declarations/src/hooks/useIdentityWallets.d.ts

@@ -0,0 +1,12 @@
+import type { Web3Wallet } from "@compilot/web-sdk";
+/**
+ * A hook that returns the current identity wallets.
+ */
+export declare const useIdentityWallets: () => {
+    identityWallets: import("../utils/useAsyncQueryState.js").AsyncQueryState<{
+        address: string;
+        namespace: "cosmos" | "tezos" | "eip155" | "aptos" | "polkadot" | "starknet" | "solana" | "cardano";
+    }[] | null>;
+    addWalletMutation: import("../utils/useAsyncMutationState.js").AsyncMutationState<(wallet: Web3Wallet) => Promise<boolean>, "attachWalletToIdentity">;
+};
+//# sourceMappingURL=useIdentityWallets.d.ts.map

package/dist/declarations/src/hooks/useIdentityWallets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIdentityWallets.d.ts","sourceRoot":"../../../../src/hooks","sources":["useIdentityWallets.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQpD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;+FAiCZ,UAAU;CAsB5B,CAAC"}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilot/react-sdk",
-  "version": "2.3.9",
+  "version": "2.3.10",
   "description": "ComPilot React SDK",
   "keywords": [],
   "license": "ISC",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilot/react-sdk",
-  "version": "2.3.9-dev",
+  "version": "2.3.10-dev",
   "description": "ComPilot React SDK",
   "keywords": [],
   "license": "ISC",
@@ -27,9 +27,9 @@
   "dependencies": {
     "pino": "^9.4.0",
     "zod": "^3.23.8",
-    "@compilot/web-sdk": "2.3.8-dev",
+    "@compilot/web-sdk": "2.3.9-dev",
     "@nexeraid/identity-api-client": "2.3.0-dev",
-    "@nexeraid/identity-schemas": "2.3.8-dev",
+    "@nexeraid/identity-schemas": "2.3.9-dev",
     "@nexeraid/logger": "2.3.0-dev"
   },
   "peerDependencies": {