@avalabs/avacloud-waas-react 1.0.10 → 1.0.14-nightly.20250704

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   AvaCloudWalletProvider: () => AvaCloudWalletProvider,
   ExportView: () => ExportView,
+  GaslessProvider: () => GaslessProvider,
   LoginButton: () => LoginButton,
   ReceiveView: () => ReceiveView,
   SendView: () => SendView,
@@ -32,9 +43,13 @@ __export(index_exports, {
   WalletButton: () => WalletButton,
   WalletCard: () => WalletCard,
   WalletDisplay: () => WalletDisplay,
+  avaCloudWallet: () => avaCloudWallet,
   useAuth: () => useAuth,
   useAvaCloudWallet: () => useAvaCloudWallet,
+  useBlockchain: () => useBlockchain,
   useChainId: () => useChainId,
+  useGaslessTransaction: () => useGaslessTransaction,
+  useGlacier: () => useGlacier,
   usePostMessage: () => usePostMessage,
   useSignMessage: () => useSignMessage,
   useSignTransaction: () => useSignTransaction,
@@ -1600,7 +1615,7 @@ var queryClient = new import_react_query2.QueryClient({
   }
 });
 function getCubistEnv(environment) {
-  return environment === "gamma" || environment === "development" ? import_cubesigner_sdk.envs.gamma : import_cubesigner_sdk.envs.prod;
+  return environment === "production" ? import_cubesigner_sdk.envs.prod : import_cubesigner_sdk.envs.gamma;
 }
 function ViemProviderWrapper({ children, chainId }) {
   const { data: blockchain } = useBlockchain(chainId.toString());
@@ -1627,6 +1642,10 @@ function AvaCloudWalletProvider({
   onAuthError,
   onWalletUpdate
 }) {
+  const { setChainId } = useChainId();
+  (0, import_react9.useEffect)(() => {
+    setChainId(chainId);
+  }, [chainId, setChainId]);
   const authServiceUrl = env === "development" ? "http://localhost:3000" : env === "staging" ? "https://ac-auth-service-env-staging-ava-labs.vercel.app" : "https://ac-auth-service.vercel.app";
   const environment = env;
   const [isAuthenticated, setIsAuthenticated] = (0, import_react9.useState)(false);
@@ -1692,7 +1711,7 @@ function AvaCloudWalletProvider({
       }
       try {
         const resp = await import_cubesigner_sdk2.CubeSignerClient.createOidcSession(
-          getCubistEnv(environment),
+          getCubistEnv(environment === "production" ? "prod" : "gamma"),
           orgConfig.walletProviderOrgID,
           accessToken,
           ["sign:*", "manage:*", "export:*"],
@@ -4524,10 +4543,451 @@ function useUserWallets() {
     isLoading
   };
 }
+
+// src/wagmi/connector.ts
+var import_core = require("@wagmi/core");
+var import_viem5 = require("viem");
+function avaCloudWallet() {
+  return (0, import_core.createConnector)((config) => ({
+    id: "avaCloudWallet",
+    name: "AvaCloud Wallet",
+    type: "injected",
+    async connect() {
+      const { walletClient } = useViem();
+      if (!walletClient) {
+        throw new Error("AvaCloud Wallet not connected");
+      }
+      const accounts = await this.getAccounts();
+      const chainId = await this.getChainId();
+      config.emitter.emit("connect", { accounts, chainId });
+      return { accounts, chainId };
+    },
+    async disconnect() {
+      config.emitter.emit("disconnect");
+    },
+    async getAccounts() {
+      const { walletClient } = useViem();
+      if (!(walletClient == null ? void 0 : walletClient.account)) {
+        throw new Error("AvaCloud Wallet not connected or account not found.");
+      }
+      return [walletClient.account.address];
+    },
+    async getChainId() {
+      const { chainId } = useViem();
+      return chainId;
+    },
+    async getProvider() {
+      const { publicClient } = useViem();
+      if (!publicClient) {
+        throw new Error("Public client not found.");
+      }
+      return publicClient;
+    },
+    async isAuthorized() {
+      const { walletClient } = useViem();
+      return !!walletClient;
+    },
+    onAccountsChanged(accounts) {
+      if (accounts.length === 0) {
+        this.disconnect();
+      } else {
+        config.emitter.emit("change", {
+          accounts: accounts.map((x) => (0, import_viem5.getAddress)(x))
+        });
+      }
+    },
+    onChainChanged(chain) {
+      const chainId = Number(chain);
+      config.emitter.emit("change", { chainId });
+    },
+    onDisconnect() {
+      config.emitter.emit("disconnect");
+    }
+  }));
+}
+
+// src/providers/GaslessProvider.tsx
+var import_react27 = require("react");
+var import_jsx_runtime24 = require("react/jsx-runtime");
+function validateGaslessConfig(config) {
+  if (!config || typeof config !== "object") {
+    return "Invalid gasless configuration: expected an object";
+  }
+  const requiredFields = [
+    { field: "relayerUrl", description: "Relayer RPC URL" },
+    { field: "subnetRpcUrl", description: "Subnet RPC URL" },
+    { field: "forwarderAddress", description: "Forwarder contract address" },
+    { field: "domainName", description: "EIP-712 domain name" },
+    { field: "domainVersion", description: "EIP-712 domain version" },
+    { field: "requestType", description: "Request type name" }
+  ];
+  const missingFields = requiredFields.filter(({ field }) => !config[field]);
+  if (missingFields.length > 0) {
+    const missing = missingFields.map(({ field, description }) => `${field} (${description})`).join(", ");
+    return `Missing required gasless configuration fields: ${missing}`;
+  }
+  try {
+    new URL(config.relayerUrl);
+  } catch (e) {
+    return `Invalid relayer URL format: ${config.relayerUrl}`;
+  }
+  try {
+    new URL(config.subnetRpcUrl);
+  } catch (e) {
+    return `Invalid subnet RPC URL format: ${config.subnetRpcUrl}`;
+  }
+  if (!config.forwarderAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
+    return `Invalid forwarder address format: ${config.forwarderAddress}. Expected a valid Ethereum address.`;
+  }
+  return null;
+}
+var GaslessContext = (0, import_react27.createContext)(null);
+function GaslessProvider({ children, config, fetchParams }) {
+  const [state, setState] = (0, import_react27.useState)({
+    isLoading: false,
+    error: null,
+    config: null
+  });
+  const { authServiceUrl, environment } = useAvaCloudWallet();
+  (0, import_react27.useEffect)(() => {
+    if (config) {
+      const validationError = validateGaslessConfig(config);
+      if (validationError) {
+        setState({
+          isLoading: false,
+          error: new Error(validationError),
+          config: null
+        });
+      } else {
+        setState({ isLoading: false, error: null, config });
+      }
+      return;
+    }
+    if (!fetchParams) {
+      setState({
+        isLoading: false,
+        error: new Error(
+          "GaslessProvider requires either a `config` prop or `fetchParams` prop. Please provide pre-fetched configuration or parameters to fetch it."
+        ),
+        config: null
+      });
+      return;
+    }
+    const { orgId, subnetId } = fetchParams;
+    if (!orgId || !subnetId) {
+      setState({
+        isLoading: false,
+        error: new Error(
+          `Invalid fetchParams: both orgId and subnetId are required. Received: orgId="${orgId}", subnetId="${subnetId}"`
+        ),
+        config: null
+      });
+      return;
+    }
+    const fetchConfig = async () => {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      try {
+        const url = `${authServiceUrl}/api/gasless-config?orgId=${encodeURIComponent(
+          orgId
+        )}&subnetId=${encodeURIComponent(subnetId)}&environment=${environment}`;
+        const resp = await fetch(url);
+        if (!resp.ok) {
+          let errorMessage = `Failed to fetch gasless configuration (HTTP ${resp.status})`;
+          try {
+            const errorData = await resp.json();
+            if (errorData.error) {
+              errorMessage = errorData.error;
+              if (errorData.details) {
+                errorMessage += `: ${errorData.details}`;
+              }
+            }
+          } catch (e) {
+            if (resp.status === 404) {
+              errorMessage = "Gas relayer configuration not found. Please ensure the gas relayer is set up for your organization and subnet in AvaCloud.";
+            } else if (resp.status === 400) {
+              errorMessage = "Invalid request parameters. Please check your orgId and subnetId.";
+            } else if (resp.status === 500) {
+              errorMessage = "Server error while fetching gasless configuration. Please try again later or contact support.";
+            }
+          }
+          throw new Error(errorMessage);
+        }
+        const cfg = await resp.json();
+        const validationError = validateGaslessConfig(cfg);
+        if (validationError) {
+          throw new Error(
+            `Invalid gasless configuration received from server: ${validationError}. This may indicate an issue with your AvaCloud gas relayer setup.`
+          );
+        }
+        setState({ isLoading: false, error: null, config: cfg });
+      } catch (err) {
+        let error;
+        if (err instanceof Error) {
+          error = err;
+        } else if (err && typeof err === "object" && "message" in err) {
+          error = new Error(String(err.message));
+        } else {
+          error = new Error("An unexpected error occurred while fetching gasless configuration");
+        }
+        setState({ isLoading: false, error, config: null });
+      }
+    };
+    fetchConfig();
+  }, [config, fetchParams, authServiceUrl, environment]);
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(GaslessContext.Provider, { value: state, children });
+}
+
+// src/hooks/useGaslessTransaction.ts
+var import_react28 = require("react");
+var ethers = __toESM(require("ethers"));
+var import_axios = __toESM(require("axios"));
+var import_cubesigner_sdk6 = require("@cubist-labs/cubesigner-sdk");
+var FORWARDER_GET_NONCE_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      }
+    ],
+    name: "getNonce",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+function useGaslessTransaction({ gaslessConfig, contractAddress: defaultContractAddress, abi: defaultAbi }) {
+  const [state, setState] = (0, import_react28.useState)({
+    isLoading: false,
+    error: null,
+    txHash: null
+  });
+  const config = gaslessConfig;
+  const { wallet, cubistClient } = useAvaCloudWallet();
+  useViem();
+  const reset = (0, import_react28.useCallback)(() => {
+    setState({
+      isLoading: false,
+      error: null,
+      txHash: null
+    });
+  }, []);
+  const validateConfig = (0, import_react28.useCallback)((config2) => {
+    if (!config2) {
+      return "Gasless configuration is not available. Please ensure GaslessProvider is properly configured.";
+    }
+    const requiredFields = [
+      { field: "relayerUrl", description: "Relayer RPC URL" },
+      { field: "subnetRpcUrl", description: "Subnet RPC URL" },
+      { field: "forwarderAddress", description: "Forwarder contract address" },
+      { field: "domainName", description: "EIP-712 domain name" },
+      { field: "domainVersion", description: "EIP-712 domain version" }
+    ];
+    if (!config2.requestType) {
+      config2.requestType = "Message";
+    }
+    for (const { field, description } of requiredFields) {
+      if (!config2[field]) {
+        return `Missing required gasless configuration field: ${field} (${description}). Please check your AvaCloud gas relayer setup.`;
+      }
+    }
+    try {
+      new URL(config2.relayerUrl);
+    } catch (e) {
+      return `Invalid relayer URL: ${config2.relayerUrl}. Expected a valid HTTP/HTTPS URL.`;
+    }
+    try {
+      new URL(config2.subnetRpcUrl);
+    } catch (e) {
+      return `Invalid subnet RPC URL: ${config2.subnetRpcUrl}. Expected a valid HTTP/HTTPS URL.`;
+    }
+    if (!config2.forwarderAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
+      return `Invalid forwarder address: ${config2.forwarderAddress}. Expected a valid Ethereum address.`;
+    }
+    return null;
+  }, []);
+  const sendGaslessTransaction = (0, import_react28.useCallback)(async ({
+    functionName,
+    args = [],
+    abi: overrideAbi,
+    contractAddress: overrideContractAddress
+  }) => {
+    const contractAddress = overrideContractAddress != null ? overrideContractAddress : defaultContractAddress;
+    const abi = overrideAbi != null ? overrideAbi : defaultAbi;
+    if (!contractAddress || !abi) {
+      setState((prev) => ({ ...prev, error: "Contract address and ABI are required. Please provide them either when initializing the hook or when calling sendGaslessTransaction." }));
+      return;
+    }
+    const configError = validateConfig(config);
+    if (configError) {
+      setState((prev) => ({ ...prev, error: configError }));
+      return;
+    }
+    if (!config) {
+      setState((prev) => ({
+        ...prev,
+        error: "Gasless configuration is not available. Please ensure you pass a valid config object when initializing useGaslessTransaction."
+      }));
+      return;
+    }
+    if (!(wallet == null ? void 0 : wallet.address)) {
+      setState((prev) => ({ ...prev, error: "Wallet not connected. Please connect your wallet before sending transactions." }));
+      return;
+    }
+    if (!cubistClient) {
+      setState((prev) => ({ ...prev, error: "Authentication client not initialized. Please ensure you are properly authenticated." }));
+      return;
+    }
+    if (!contractAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
+      setState((prev) => ({ ...prev, error: `Invalid contract address: ${contractAddress}. Expected a valid Ethereum address.` }));
+      return;
+    }
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const provider = new ethers.providers.JsonRpcProvider(config.subnetRpcUrl);
+      const forwarder = new ethers.Contract(config.forwarderAddress, FORWARDER_GET_NONCE_ABI, provider);
+      const targetContract = new ethers.Contract(contractAddress, abi, provider);
+      const gas = await targetContract.estimateGas[functionName](...args);
+      const forwarderNonce = await forwarder.getNonce(wallet.address);
+      const data = targetContract.interface.encodeFunctionData(functionName, args);
+      const types = {
+        EIP712Domain: [
+          { name: "name", type: "string" },
+          { name: "version", type: "string" },
+          { name: "chainId", type: "uint256" },
+          { name: "verifyingContract", type: "address" }
+        ],
+        [config.requestType]: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "gas", type: "uint256" },
+          { name: "nonce", type: "uint256" },
+          { name: "data", type: "bytes" },
+          { name: "validUntilTime", type: "uint256" }
+        ]
+      };
+      if (config.suffix) {
+        const suffixParts = config.suffix.match(/^(\w+)\s+(.+)\)$/);
+        if (suffixParts) {
+          const [, suffixType, suffixName] = suffixParts;
+          types[config.requestType].push({
+            name: suffixName,
+            type: suffixType
+          });
+        }
+      }
+      const nonceHex = forwarderNonce.toHexString();
+      const message = {
+        from: wallet.address,
+        to: contractAddress,
+        value: "0x0",
+        gas: gas.toHexString(),
+        nonce: nonceHex,
+        data,
+        validUntilTime: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+      };
+      if (config.suffix) {
+        const suffixParts = config.suffix.match(/^(\w+)\s+(.+)\)$/);
+        if (suffixParts) {
+          const [, , suffixName] = suffixParts;
+          message[suffixName] = Buffer.from(config.suffix, "utf8");
+        }
+      }
+      const domain = {
+        name: config.domainName,
+        version: config.domainVersion,
+        chainId: (await provider.getNetwork()).chainId,
+        verifyingContract: config.forwarderAddress
+      };
+      const digest = ethers.utils._TypedDataEncoder.hash(domain, {
+        [config.requestType]: types[config.requestType]
+      }, message);
+      const key = await cubistClient.org().getKeyByMaterialId(import_cubesigner_sdk6.Secp256k1.Evm, wallet.address);
+      const sigResp = await key.signBlob({
+        message_base64: Buffer.from(digest.slice(2), "hex").toString("base64")
+      });
+      const signatureData = sigResp.data().signature;
+      const signature = signatureData.startsWith("0x") ? signatureData : `0x${signatureData}`;
+      const typedRequest = {
+        domain,
+        types: {
+          [config.requestType]: types[config.requestType]
+        },
+        primaryType: config.requestType,
+        message
+      };
+      const txPayload = {
+        forwardRequest: typedRequest,
+        metadata: {
+          signature: signature.substring(2)
+          // strip 0x
+        }
+      };
+      const rawTx = "0x" + Buffer.from(JSON.stringify(txPayload), "utf8").toString("hex");
+      const requestBody = {
+        id: 1,
+        jsonrpc: "2.0",
+        method: "eth_sendRawTransaction",
+        params: [rawTx]
+      };
+      const resp = await import_axios.default.post(config.relayerUrl, requestBody, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      const txHash = resp.data.result;
+      setState((prev) => ({ ...prev, txHash }));
+      await provider.waitForTransaction(txHash);
+    } catch (err) {
+      let errorMessage = "Failed to send gasless transaction";
+      if (err instanceof Error) {
+        if (err.message.includes("estimateGas")) {
+          errorMessage = `Failed to estimate gas for function "${functionName}". Please verify the function exists and parameters are correct.`;
+        } else if (err.message.includes("getNonce")) {
+          errorMessage = "Failed to fetch nonce from forwarder contract. Please verify the forwarder address is correct and deployed.";
+        } else if (err.message.includes("getKeyByMaterialId")) {
+          errorMessage = "Failed to retrieve signing key. Please ensure your wallet is properly initialized.";
+        } else if (err.message.includes("signBlob")) {
+          errorMessage = "Failed to sign transaction. Please check your authentication status.";
+        } else if (err.message.includes("Network Error") || err.message.includes("ECONNREFUSED")) {
+          errorMessage = "Network error: Unable to connect to relayer service. Please check your internet connection and relayer URL.";
+        } else if (err.message.includes("404")) {
+          errorMessage = "Relayer endpoint not found. Please verify the relayer URL is correct.";
+        } else if (err.message.includes("500") || err.message.includes("502") || err.message.includes("503")) {
+          errorMessage = "Relayer service error. The gas relayer service may be temporarily unavailable.";
+        } else if (err.message.includes("insufficient funds")) {
+          errorMessage = "The relayer has insufficient funds to sponsor this transaction. Please contact support.";
+        } else {
+          errorMessage = `Transaction failed: ${err.message}`;
+        }
+      }
+      setState((prev) => ({
+        ...prev,
+        error: errorMessage
+      }));
+    } finally {
+      setState((prev) => ({ ...prev, isLoading: false }));
+    }
+  }, [config, wallet == null ? void 0 : wallet.address, cubistClient, validateConfig, defaultAbi, defaultContractAddress]);
+  return {
+    ...state,
+    sendGaslessTransaction,
+    reset
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AvaCloudWalletProvider,
   ExportView,
+  GaslessProvider,
   LoginButton,
   ReceiveView,
   SendView,
@@ -4538,9 +4998,13 @@ function useUserWallets() {
   WalletButton,
   WalletCard,
   WalletDisplay,
+  avaCloudWallet,
   useAuth,
   useAvaCloudWallet,
+  useBlockchain,
   useChainId,
+  useGaslessTransaction,
+  useGlacier,
   usePostMessage,
   useSignMessage,
   useSignTransaction,