@frontiertower/frontier-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,480 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChainAccess: () => ChainAccess,
+  FrontierSDK: () => FrontierSDK,
+  StorageAccess: () => StorageAccess,
+  UserAccess: () => UserAccess,
+  WalletAccess: () => WalletAccess
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/access/wallet.ts
+var WalletAccess = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Get the current wallet balance
+   * 
+   * Returns the total USD stablecoin balance for the current network,
+   * normalized to 18 decimals for consistency.
+   * 
+   * @returns Balance as bigint (18 decimals)
+   * @throws {Error} If no wallet exists
+   * 
+   * @example
+   * ```typescript
+   * const balance = await sdk.getWallet().getBalance();
+   * console.log('Balance:', balance.toString());
+   * ```
+   */
+  async getBalance() {
+    return this.sdk.request("wallet:getBalance");
+  }
+  /**
+   * Get the current wallet balance formatted for display
+   * 
+   * Returns the total USD stablecoin balance as a formatted string
+   * with currency symbol (e.g., '$10.50').
+   * 
+   * @returns Formatted balance string with $ sign
+   * @throws {Error} If no wallet exists
+   * 
+   * @example
+   * ```typescript
+   * const balance = await sdk.getWallet().getBalanceFormatted();
+   * console.log('Balance:', balance); // '$10.50'
+   * ```
+   */
+  async getBalanceFormatted() {
+    return this.sdk.request("wallet:getBalanceFormatted");
+  }
+  /**
+   * Get the wallet address for the current network
+   * 
+   * Returns the smart account contract address for the current chain.
+   * 
+   * @returns The wallet address as a hex string
+   * @throws {Error} If no wallet exists
+   * 
+   * @example
+   * ```typescript
+   * const address = await sdk.getWallet().getAddress();
+   * console.log('Address:', address);
+   * ```
+   */
+  async getAddress() {
+    return this.sdk.request("wallet:getAddress");
+  }
+  /**
+   * Get smart account for the current network
+   * 
+   * Returns detailed information about the smart account including
+   * deployment status and network information.
+   * 
+   * @returns Smart account information
+   * @throws {Error} If no smart account found for current network
+   * 
+   * @example
+   * ```typescript
+   * const account = await sdk.getWallet().getSmartAccount();
+   * console.log('Contract address:', account.contractAddress);
+   * console.log('Network:', account.network);
+   * ```
+   */
+  async getSmartAccount() {
+    return this.sdk.request("wallet:getSmartAccount");
+  }
+  /**
+   * Transfer ERC20 tokens
+   * 
+   * Sends ERC20 tokens to a recipient address using the current network.
+   * Requires biometric authentication and sufficient balance.
+   * 
+   * @param tokenAddress - ERC20 token contract address
+   * @param to - Recipient address
+   * @param amount - Amount to send (in token's smallest unit, e.g., wei)
+   * @param overrides - Optional gas overrides
+   * @returns User operation receipt with transaction details
+   * @throws {Error} If insufficient balance or transaction fails
+   * 
+   * @example
+   * ```typescript
+   * import { parseUnits } from 'viem';
+   * 
+   * const receipt = await sdk.getWallet().transferERC20(
+   *   '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', // USDC on Sepolia
+   *   '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+   *   parseUnits('10.5', 6) // 10.5 USDC (6 decimals)
+   * );
+   * console.log('Transaction:', receipt.transactionHash);
+   * ```
+   */
+  async transferERC20(tokenAddress, to, amount, overrides) {
+    return this.sdk.request("wallet:transferERC20", {
+      tokenAddress,
+      to,
+      amount,
+      overrides
+    });
+  }
+  /**
+   * Approve ERC20 tokens for spending
+   * 
+   * Approves a spender to transfer tokens on your behalf.
+   * Required before interacting with DeFi protocols.
+   * 
+   * @param tokenAddress - ERC20 token contract address
+   * @param spender - Address allowed to spend tokens
+   * @param amount - Amount to approve (in token's smallest unit)
+   * @param overrides - Optional gas overrides
+   * @returns User operation receipt with transaction details
+   * @throws {Error} If transaction fails
+   * 
+   * @example
+   * ```typescript
+   * import { parseUnits } from 'viem';
+   * 
+   * const receipt = await sdk.getWallet().approveERC20(
+   *   '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', // USDC
+   *   '0xProtocolAddress',
+   *   parseUnits('100', 6) // Approve 100 USDC
+   * );
+   * ```
+   */
+  async approveERC20(tokenAddress, spender, amount, overrides) {
+    return this.sdk.request("wallet:approveERC20", {
+      tokenAddress,
+      spender,
+      amount,
+      overrides
+    });
+  }
+  /**
+   * Transfer native currency (ETH)
+   * 
+   * Sends native currency to a recipient address.
+   * Requires biometric authentication and sufficient balance.
+   * 
+   * @param to - Recipient address
+   * @param amount - Amount to send in wei
+   * @param overrides - Optional gas overrides
+   * @returns User operation receipt with transaction details
+   * @throws {Error} If insufficient balance or transaction fails
+   * 
+   * @example
+   * ```typescript
+   * import { parseEther } from 'viem';
+   * 
+   * const receipt = await sdk.getWallet().transferNative(
+   *   '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+   *   parseEther('0.1') // 0.1 ETH
+   * );
+   * ```
+   */
+  async transferNative(to, amount, overrides) {
+    return this.sdk.request("wallet:transferNative", {
+      to,
+      amount,
+      overrides
+    });
+  }
+  /**
+   * Execute arbitrary contract call
+   * 
+   * Executes a custom contract interaction with full control over
+   * the target address, value, and calldata.
+   * 
+   * @param call - Execute call parameters
+   * @param overrides - Optional gas overrides
+   * @returns User operation receipt with transaction details
+   * @throws {Error} If transaction fails
+   * 
+   * @example
+   * ```typescript
+   * import { encodeFunctionData } from 'viem';
+   * 
+   * const receipt = await sdk.getWallet().executeCall({
+   *   to: '0xContractAddress',
+   *   value: 0n,
+   *   data: encodeFunctionData({
+   *     abi: contractABI,
+   *     functionName: 'someFunction',
+   *     args: [arg1, arg2]
+   *   })
+   * });
+   * ```
+   */
+  async executeCall(call, overrides) {
+    return this.sdk.request("wallet:executeCall", {
+      call,
+      overrides
+    });
+  }
+};
+
+// src/access/storage.ts
+var StorageAccess = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Get data from persistent storage
+   * Requires permission: storage:get or storage:*
+   */
+  async get(key) {
+    return this.sdk.request("storage:get", { key });
+  }
+  /**
+   * Store data persistently
+   * Requires permission: storage:set or storage:*
+   */
+  async set(key, value) {
+    return this.sdk.request("storage:set", { key, value });
+  }
+  /**
+   * Remove data from persistent storage
+   * Requires permission: storage:remove or storage:*
+   */
+  async remove(key) {
+    return this.sdk.request("storage:remove", { key });
+  }
+  /**
+   * Clear all data from persistent storage
+   * Requires permission: storage:clear or storage:*
+   */
+  async clear() {
+    return this.sdk.request("storage:clear");
+  }
+};
+
+// src/access/chain.ts
+var ChainAccess = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Get the current network name
+   * 
+   * Returns the network identifier for the currently active chain
+   * (e.g., 'base', 'base-sepolia', 'ethereum').
+   * 
+   * @returns Network identifier string
+   * 
+   * @example
+   * ```typescript
+   * const network = await sdk.getChain().getCurrentNetwork();
+   * console.log('Current network:', network); // 'base-sepolia'
+   * ```
+   */
+  async getCurrentNetwork() {
+    return this.sdk.request("chain:getCurrentNetwork");
+  }
+  /**
+   * Get all available networks
+   * 
+   * Returns a list of network identifiers that the app can switch to.
+   * 
+   * @returns Array of network identifier strings
+   * 
+   * @example
+   * ```typescript
+   * const networks = await sdk.getChain().getAvailableNetworks();
+   * console.log('Available networks:', networks); // ['base', 'base-sepolia']
+   * ```
+   */
+  async getAvailableNetworks() {
+    return this.sdk.request("chain:getAvailableNetworks");
+  }
+  /**
+   * Switch to a different network
+   * 
+   * Changes the active blockchain network. This will affect all subsequent
+   * wallet operations and contract interactions.
+   * 
+   * @param network - The network identifier to switch to
+   * @throws {Error} If the network is not available or switching fails
+   * 
+   * @example
+   * ```typescript
+   * await sdk.getChain().switchNetwork('base');
+   * console.log('Switched to Base mainnet');
+   * ```
+   */
+  async switchNetwork(network) {
+    return this.sdk.request("chain:switchNetwork", { network });
+  }
+  /**
+   * Get full chain configuration for current network
+   * 
+   * Returns detailed configuration including chain ID, RPC URLs,
+   * block explorer, and native currency information.
+   * 
+   * @returns Complete chain configuration object
+   * 
+   * @example
+   * ```typescript
+   * const config = await sdk.getChain().getCurrentChainConfig();
+   * console.log('Chain ID:', config.id);
+   * console.log('Block explorer:', config.blockExplorer.url);
+   * ```
+   */
+  async getCurrentChainConfig() {
+    return this.sdk.request("chain:getCurrentChainConfig");
+  }
+};
+
+// src/access/user.ts
+var UserAccess = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  /**
+   * Get current user details
+   * 
+   * Returns basic information about the currently authenticated user,
+   * including their ID, email, and name.
+   * 
+   * @returns User object with basic information
+   * @throws {Error} If user is not authenticated
+   * 
+   * @example
+   * ```typescript
+   * const user = await sdk.getUser().getDetails();
+   * console.log('User email:', user.email);
+   * console.log('User name:', `${user.firstName} ${user.lastName}`);
+   * ```
+   */
+  async getDetails() {
+    return this.sdk.request("user:getDetails");
+  }
+  /**
+   * Get user profile by ID
+   * 
+   * Returns detailed profile information for a specific user,
+   * including social media handles, preferences, and community information.
+   * 
+   * @param id - The profile ID to fetch
+   * @returns UserProfile object with detailed information
+   * @throws {Error} If profile is not found or access is denied
+   * 
+   * @example
+   * ```typescript
+   * const profile = await sdk.getUser().getProfile(123);
+   * console.log('Nickname:', profile.nickname);
+   * console.log('GitHub:', profile.githubHandle);
+   * console.log('Community:', profile.communityName);
+   * ```
+   */
+  async getProfile(id) {
+    return this.sdk.request("user:getProfile", { id });
+  }
+};
+
+// src/sdk.ts
+var FrontierSDK = class {
+  constructor() {
+    this.requestId = 0;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.handleMessage = (event) => {
+      if (event.source !== window.parent) return;
+      const response = event.data;
+      const pending = this.pendingRequests.get(response.requestId);
+      if (pending) {
+        if (response.type === "error") {
+          pending.reject(new Error(response.error));
+        } else {
+          pending.resolve(response.result);
+        }
+        this.pendingRequests.delete(response.requestId);
+      }
+    };
+    this.wallet = new WalletAccess(this);
+    this.storage = new StorageAccess(this);
+    this.chain = new ChainAccess(this);
+    this.user = new UserAccess(this);
+    window.addEventListener("message", this.handleMessage);
+    this.notifyReady();
+  }
+  /**
+   * Internal request method used by access classes
+   * @internal
+   */
+  request(type, payload) {
+    return new Promise((resolve, reject) => {
+      const requestId = `${Date.now()}-${this.requestId++}`;
+      this.pendingRequests.set(requestId, { resolve, reject });
+      const request = { type, requestId, payload };
+      window.parent.postMessage(request, "*");
+      setTimeout(() => {
+        if (this.pendingRequests.has(requestId)) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Request timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  notifyReady() {
+    window.parent.postMessage({ type: "app:ready", payload: null }, "*");
+  }
+  /**
+   * Get wallet access instance
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get storage access instance
+   */
+  getStorage() {
+    return this.storage;
+  }
+  /**
+   * Get chain access instance
+   */
+  getChain() {
+    return this.chain;
+  }
+  /**
+   * Get user access instance
+   */
+  getUser() {
+    return this.user;
+  }
+  /**
+   * Cleanup: Remove event listeners
+   * Call this when your app is being destroyed
+   */
+  destroy() {
+    window.removeEventListener("message", this.handleMessage);
+    this.pendingRequests.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChainAccess,
+  FrontierSDK,
+  StorageAccess,
+  UserAccess,
+  WalletAccess
+});