blockxy-flux 1.0.0

package/README.md

@@ -0,0 +1,91 @@
+# Flux SDK
+
+## Overview
+Flux SDK enables gasless transactions for Web3 applications, allowing users to interact with blockchain networks without paying gas fees. It supports both EVM chains (like Ethereum and Polygon) and Solana.
+
+For EVM chains, it integrates with meta-transaction relayers like Biconomy. For Solana, it uses a custom relayer to sponsor transactions.
+
+## Features
+- Gasless transactions using meta-transactions (EVM) or a relayer (Solana)
+- Supports Ethereum, Polygon, and other EVM-compatible chains
+- Supports Solana (Devnet)
+- Easy frontend integration
+- NPM package for simplified deployment
+
+## Folder Structure
+```
+flux-sdk/
+│── contracts/          # Smart contracts for relaying transactions (EVM)
+│── relayer/            # Biconomy client configuration (EVM)
+│── solana-relayer/     # Node.js service for relaying Solana transactions
+│── sdk/                # JavaScript SDK for frontend integration
+│   ├── solana/         # Solana-specific SDK modules
+│   └── ...
+│── dashboard/          # Admin dashboard with GraphQL support
+│── docs/               # Documentation
+│── frontend/           # Example frontend integration
+│── package.json        # NPM configuration
+│── README.md           # SDK overview
+```
+
+## Installation
+Clone the repository and install dependencies:
+```sh
+npm install
+```
+
+## Usage
+
+### EVM (Ethereum, Polygon, etc.)
+
+Import the SDK in your JavaScript application:
+```js
+import { sendEVMApiBiconomy } from 'flux-sdk/sdk';
+
+// ... connect to wallet ...
+
+// Example of calling a smart contract
+sendEVMApiBiconomy(contractAddress, abi, 'functionName', [arg1, arg2], userAddress);
+```
+
+### Solana
+
+Import the Solana part of the SDK:
+```js
+import { solanaGasless } from 'flux-sdk/sdk';
+import { Connection, Transaction, SystemProgram, sendAndConfirmTransaction } from '@solana/web3.js';
+
+// ... connect to solana wallet (e.g. Phantom) ...
+
+const connection = new Connection('https://api.devnet.solana.com');
+const transaction = new Transaction().add(
+  SystemProgram.transfer({
+    fromPubkey: wallet.publicKey,
+    toPubkey: otherPublicKey,
+    lamports: 1000,
+  })
+);
+
+const signature = await solanaGasless.sendGaslessTransaction(connection, wallet, transaction);
+console.log('Transaction signature:', signature);
+```
+
+## Running the Solana Relayer
+To enable gasless transactions on Solana, you need to run the Solana relayer.
+
+First, you need to configure the relayer with a secret key. Create a `.env` file in the `solana-relayer` directory with the following content:
+```
+RELAYER_SECRET_KEY=YOUR_SOLANA_SECRET_KEY_IN_BS58_FORMAT
+```
+You can generate a new keypair using the Solana CLI: `solana-keygen new`. Make sure your relayer account has enough SOL to pay for transaction fees.
+
+Navigate to the root directory and start the relayer service:
+```sh
+npm run start:solana-relayer
+```
+
+## Frontend Example
+Open `frontend/index.html` in a browser to test the gasless transaction flow. You will need to update it to include Solana examples.
+
+## License
+MIT License.

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "blockxy-flux",
+  "version": "1.0.0",
+  "description": "Flux is a gasless transaction SDK for Web3",
+  "main": "sdk/index.js",
+  "files": [
+    "sdk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Blockxyprotocols/Flux.git"
+  },
+  "scripts": {
+    "test": "mocha",
+    "build": "webpack",
+    "start:solana-relayer": "node solana-relayer/index.js"
+  },
+  "dependencies": {
+    "@biconomy/mexa": "^1.0.0",
+    "ethers": "^5.7.0",
+    "@solana/web3.js": "^1.91.4",
+    "@solana/wallet-adapter-base": "^0.9.23",
+    "@solana/wallet-adapter-wallets": "^0.19.32",
+    "express": "^4.18.2",
+    "cors": "^2.8.5",
+    "bs58": "^5.0.0"
+  },
+  "devDependencies": {
+    "mocha": "^9.0.0",
+    "webpack": "^5.0.0"
+  },
+  "keywords": ["Flux", "web3", "sdk"],
+  "author": "Blockxy Protocols",
+  "license": "MIT"
+}

package/sdk/index.js

@@ -0,0 +1,13 @@
+import { ethers } from "ethers";
+import biconomy from "../relayer/biconomy";
+import * as solana from './solana';
+
+export async function sendEVMApiBiconomy(contractAddress, abi, functionName, args, userAddress) {
+  const provider = new ethers.providers.Web3Provider(window.ethereum);
+  const signer = provider.getSigner();
+  const contract = new ethers.Contract(contractAddress, abi, signer);
+  const tx = await contract.populateTransaction[functionName](...args);
+  return biconomy.sendTransaction(tx, userAddress);
+}
+
+export const solanaGasless = solana;

package/sdk/metamask.js

@@ -0,0 +1,10 @@
+import { ethers } from "ethers";
+export async function connectWallet() {
+  if (window.ethereum) {
+    const provider = new ethers.providers.Web3Provider(window.ethereum);
+    await provider.send("eth_requestAccounts", []);
+    return provider.getSigner();
+  } else {
+    throw new Error("MetaMask not installed");
+  }
+}

package/sdk/solana/config.js

@@ -0,0 +1,3 @@
+// This is a placeholder public key. In a real application, this should be fetched
+// from the relayer or a configuration service.
+export const RELAYER_PUBLIC_KEY = 'Gf2tDk4vDxDk3jEWjH4gJt4v5nF1y2xZc3v4w5bA6nCd'; 

package/sdk/solana/index.js

@@ -0,0 +1,23 @@
+import { Transaction, PublicKey } from '@solana/web3.js';
+import { sendTransaction as sendRelayedTransaction } from './utils';
+import { RELAYER_PUBLIC_KEY } from './config';
+
+export async function sendGaslessTransaction(connection, wallet, transaction) {
+  const relayerPublicKey = new PublicKey(RELAYER_PUBLIC_KEY);
+  
+  // Set the fee payer to be the relayer
+  transaction.feePayer = relayerPublicKey;
+  
+  // Get a recent blockhash
+  const { blockhash } = await connection.getRecentBlockhash();
+  transaction.recentBlockhash = blockhash;
+  
+  // The wallet signs the transaction
+  const signedTransaction = await wallet.signTransaction(transaction);
+
+  // The signed transaction is sent to the relayer
+  const signature = await sendRelayedTransaction(signedTransaction);
+
+  // Return the signature of the relayed transaction
+  return signature;
+} 

package/sdk/solana/utils.js

@@ -0,0 +1,20 @@
+const RELAYER_URL = 'http://localhost:3001/relay';
+
+export async function sendTransaction(signedTransaction) {
+  const response = await fetch(RELAYER_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      transaction: signedTransaction.serialize().toString('base64'),
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to send transaction to relayer');
+  }
+
+  const { signature } = await response.json();
+  return signature;
+} 

package/sdk/solana/wallet.js

@@ -0,0 +1,7 @@
+import { WalletAdapterNetwork } from '@solana/wallet-adapter-base';
+import { getPhantomWallet } from '@solana/wallet-adapter-wallets';
+
+export function getWallet(network = WalletAdapterNetwork.Devnet) {
+  const wallets = [getPhantomWallet()];
+  return wallets[0];
+}