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

package/dist/index.mjs

@@ -1554,7 +1554,7 @@ var queryClient = new QueryClient({
   }
 });
 function getCubistEnv(environment) {
-  return environment === "gamma" || environment === "development" ? envs.gamma : envs.prod;
+  return environment === "production" ? envs.prod : envs.gamma;
 }
 function ViemProviderWrapper({ children, chainId }) {
   const { data: blockchain } = useBlockchain(chainId.toString());
@@ -1581,6 +1581,10 @@ function AvaCloudWalletProvider({
   onAuthError,
   onWalletUpdate
 }) {
+  const { setChainId } = useChainId();
+  useEffect5(() => {
+    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] = useState7(false);
@@ -1646,7 +1650,7 @@ function AvaCloudWalletProvider({
       }
       try {
         const resp = await CubeSignerClient.createOidcSession(
-          getCubistEnv(environment),
+          getCubistEnv(environment === "production" ? "prod" : "gamma"),
           orgConfig.walletProviderOrgID,
           accessToken,
           ["sign:*", "manage:*", "export:*"],
@@ -4556,9 +4560,454 @@ function useUserWallets() {
     isLoading
   };
 }
+
+// src/wagmi/connector.ts
+import {
+  createConnector
+} from "@wagmi/core";
+import {
+  getAddress
+} from "viem";
+function avaCloudWallet() {
+  return 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) => getAddress(x))
+        });
+      }
+    },
+    onChainChanged(chain) {
+      const chainId = Number(chain);
+      config.emitter.emit("change", { chainId });
+    },
+    onDisconnect() {
+      config.emitter.emit("disconnect");
+    }
+  }));
+}
+
+// src/providers/GaslessProvider.tsx
+import { createContext as createContext5, useContext as useContext5, useEffect as useEffect7, useState as useState21 } from "react";
+import { jsx as jsx24 } from "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 = createContext5(null);
+function GaslessProvider({ children, config, fetchParams }) {
+  const [state, setState] = useState21({
+    isLoading: false,
+    error: null,
+    config: null
+  });
+  const { authServiceUrl, environment } = useAvaCloudWallet();
+  useEffect7(() => {
+    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__ */ jsx24(GaslessContext.Provider, { value: state, children });
+}
+
+// src/hooks/useGaslessTransaction.ts
+import { useCallback as useCallback11, useState as useState22 } from "react";
+import * as ethers from "ethers";
+import axios from "axios";
+import { Secp256k1 as Secp256k14 } from "@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] = useState22({
+    isLoading: false,
+    error: null,
+    txHash: null
+  });
+  const config = gaslessConfig;
+  const { wallet, cubistClient } = useAvaCloudWallet();
+  useViem();
+  const reset = useCallback11(() => {
+    setState({
+      isLoading: false,
+      error: null,
+      txHash: null
+    });
+  }, []);
+  const validateConfig = useCallback11((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 = useCallback11(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(Secp256k14.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 axios.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
+  };
+}
 export {
   AvaCloudWalletProvider,
   ExportView,
+  GaslessProvider,
   LoginButton,
   ReceiveView,
   SendView,
@@ -4569,9 +5018,13 @@ export {
   WalletButton,
   WalletCard,
   WalletDisplay,
+  avaCloudWallet,
   useAuth,
   useAvaCloudWallet,
+  useBlockchain,
   useChainId,
+  useGaslessTransaction,
+  useGlacier,
   usePostMessage,
   useSignMessage,
   useSignTransaction,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avalabs/avacloud-waas-react",
-  "version": "1.0.10",
+  "version": "1.0.14-nightly.20250704",
   "description": "React SDK for AvaCloud Wallet as a Service",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -10,8 +10,16 @@
   "files": [
     "dist/**"
   ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --external react && cp -r public/* dist/",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts --external react",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
   "devDependencies": {
     "@iconify/types": "^2.0.0",
+    "@types/node": "^20.9.0",
     "@types/react": "^18.2.46",
     "@types/react-dom": "^18.2.18",
     "eslint": "^8.53.0",
@@ -28,9 +36,12 @@
     "@cubist-labs/cubesigner-sdk": "0.4.110-0",
     "@iconify/react": "^4.1.1",
     "@tanstack/react-query": "^5.64.2",
+    "@wagmi/core": "^2.17.3",
     "lottie-react": "^2.4.0",
     "qrcode.react": "^3.1.0",
-    "viem": "^2.5.0"
+    "viem": "2.31.2",
+    "ethers": "^5.7.2",
+    "axios": "^1.6.0"
   },
   "keywords": [
     "avalanche",
@@ -49,11 +60,5 @@
     "url": "https://github.com/ava-labs/avacloud-auth-react/issues"
   },
   "homepage": "https://github.com/ava-labs/avacloud-auth-react#readme",
-  "author": "Ava Labs, Inc.",
-  "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --external react && cp -r public/* dist/",
-    "dev": "tsup src/index.ts --format esm,cjs --watch --dts --external react",
-    "lint": "eslint \"src/**/*.ts*\"",
-    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
-  }
-}
+  "author": "Ava Labs, Inc."
+}