gun-eth 2.0.1 → 3.0.0

package/README.md

@@ -1,207 +1,386 @@
-# GUN-ETH
+# Gun-ETH 🔫
 
-<img src="https://imgs.search.brave.com/RM76D4wyToxCzGffJLw33O_L3glhpIVS3KLvXehpMt8/rs:fit:500:0:0:0/g:ce/aHR0cHM6Ly93d3cu/dXNlcmxvZ29zLm9y/Zy9maWxlcy9sb2dv/cy9mZXJuYW5kb3Nh/bnR1Y2NpLzI5NDY5/X2d1bmRiLWxvZ28u/cG5n" alt="gun" width="200"/>
-<img src="https://imgs.search.brave.com/kQyriTMPqw42DEhIQj3eEKIcLZu_C4nNIVR8KtAn3lo/rs:fit:500:0:0:0/g:ce/aHR0cHM6Ly93d3cu/bG9nby53aW5lL2Ev/bG9nby9FdGhlcmV1/bS9FdGhlcmV1bS1E/aWFtb25kLUxvZ28u/d2luZS5zdmc" alt="eth" width="200"/>
+<img src="landing/assets/hero-image.webp" alt="Gun-ETH Logo" width="300">
 
-## Table of Contents
+A powerful Gun.js plugin that extends its capabilities by adding advanced blockchain and cryptographic features to create more secure and private decentralized applications.
 
-1. [DESCRIPTION](#description)
-2. [SMART CONTRACT](#smart-contract)
-3. [KEY FEATURES](#key-features)
-4. [HOW TO INSTALL](#how-to-install)
-5. [HOW TO USE](#how-to-use)
-6. [HOW IT WORKS](#how-it-works)  
-7. [CORE FUNCTIONS](#core-functions)
-8. [SHINE](#shine)
-9. [STANDALONE MODE](#standalone-mode)
-10. [SECURITY CONSIDERATIONS](#security-considerations)
-11. [CONTRIBUTING](#contributing)
-12. [LICENSE](#license)
-13. [CONTACT](#contact)
+## ✨ Why Gun-ETH?
 
-## DESCRIPTION
+- 🎯 **Powerful Extension**: Adds advanced blockchain and cryptographic features to Gun.js
+- 🌐 **Seamless Integration**: Perfectly integrates with Gun.js while maintaining simplicity
+- 🔒 **Advanced Privacy**: Implements stealth transactions, proof chain, and encrypted data
+- 🚀 **Modern Architecture**: Intuitive APIs for easy Web3 functionality implementation
 
-Gun-eth is a plugin for GunDB that integrates Ethereum and Web3 functionality. This plugin extends GunDB's capabilities by allowing interaction with the Ethereum blockchain and providing cryptographic and signature management features.
+## 🚀 Quick Start
 
-## SMART CONTRACT
-
-SHINE Smart Contract deployed on Optimism Sepolia: [0x43D838b683F772F08f321E5FA265ad3e333BE9C2](https://sepolia-optimism.etherscan.io/address/0x43D838b683F772F08f321E5FA265ad3e333BE9C2)
-
-Currently, the contract is deployed only on Optimism Sepolia. In the future, it will be deployed on multiple chains.
-
-## No time? Check the [TUTORIAL](./TUTORIAL.md)
-
-## KEY FEATURES
-
-- **Ethereum Signature Verification**: Verify Ethereum signatures for messages.
-- **Password Generation**: Generate secure passwords from Ethereum signatures.
-- **Signature Creation**: Create Ethereum signatures for messages.
-- **Encrypted Key Pair Management**: Create, store, and retrieve encrypted key pairs.
-- **SHINE Implementation**: Implement the SHINE for data verification on the blockchain.
-- **Custom Token Management**: Set and retrieve custom tokens for Gun operations.
-
-## HOW TO INSTALL
+### Installation
 
 ```bash
 npm install gun-eth
+# or
+yarn add gun-eth
 ```
 
+### Basic Configuration
+
 ```javascript
-import gun from "gun";
-import "gun-eth";
+import Gun from 'gun';
+import { GunEth } from 'gun-eth';
+import { ethers } from 'ethers';
 
-const gun = Gun();
+// Configure Gun with peers
+const gun = Gun({
+    peers: ['http://localhost:8765/gun']
+});
 
-await gun.generatePassword("YOUR_SIGNATURE");
+// Initialize GunEth
+const gunEth = await GunEth.init('localhost'); // or 'mainnet', 'sepolia', etc.
 ```
 
-## HOW TO USE
-
-Learn more about Gun.js [here](https://gun.eco/docs/Getting-Started).
-
-Learn more about plugin implementation [here](https://github.com/amark/gun/wiki/Adding-Methods-to-the-Gun-Chain#abstraction-layers).
-
-
-## HOW IT WORKS
+### Signer Configuration
 
-### Create KeyPair
+Gun-ETH provides two ways to configure the signer:
 
+1. **Manual Configuration (Recommended for Production)**
+```javascript
+import { setSigner, getSigner } from 'gun-eth';
 
-[![](https://mermaid.ink/img/pako:eNpdUUtuwjAQvcrIGzZwgSwqJSRQhEorwqZNWLjxkFgkduSPEAJu1Fv0Yp0khaj1wh6P3s_jCyu0QBawQ61PRcWNg12cKxhWmK2T97dwtYVlskm24W71utnDbPYE0SWVpUIDJdLOHQIHSx3uvEE4SVdBJS2ceF2juz0Eo458Tb-_rjDPlnfqGs8tl2agpUm4f-DnvVmcJaow59aBq_6hR09vpSqh9OqvQtwrJGQ2sBU9F7TqgHEEEzpm6KoJEGjiLRrbl1wIg9aOMkkvs8hSp8kLhzgo4PgbRnaKn3E0MhY945miiz2bsgZNw6WgSV86SM4oTIM5C6gU3Bxz1rfVjbDcO52eVcECZzxOmdG-rFhw4LWlm28FDS2WvDS8eXRRSIr2Mnxm_6dT1nL1ofUdc_sBNpWchQ?type=png)](https://mermaid.live/edit#pako:eNpdUUtuwjAQvcrIGzZwgSwqJSRQhEorwqZNWLjxkFgkduSPEAJu1Fv0Yp0khaj1wh6P3s_jCyu0QBawQ61PRcWNg12cKxhWmK2T97dwtYVlskm24W71utnDbPYE0SWVpUIDJdLOHQIHSx3uvEE4SVdBJS2ceF2juz0Eo458Tb-_rjDPlnfqGs8tl2agpUm4f-DnvVmcJaow59aBq_6hR09vpSqh9OqvQtwrJGQ2sBU9F7TqgHEEEzpm6KoJEGjiLRrbl1wIg9aOMkkvs8hSp8kLhzgo4PgbRnaKn3E0MhY945miiz2bsgZNw6WgSV86SM4oTIM5C6gU3Bxz1rfVjbDcO52eVcECZzxOmdG-rFhw4LWlm28FDS2WvDS8eXRRSIr2Mnxm_6dT1nL1ofUdc_sBNpWchQ)
-
-### Retrive KeyPair
-----
-
-[![](https://mermaid.ink/img/pako:eNplUsluwjAQ_ZWRz_ADObQCEiggOLAc2iQHN56ABbGjsU2FAv_erBBBLs7Yb5lnT8ESLZB5LD3rv-TIycLOjxSU3yjc7kabnQcbtCTxgrDEa84lxTAcfsC42BskyElfpEADXAhCU65KgJEHxa0j_Lw3WuOKcvtGc4NJ-NBDldA1tyjg1ChDSjqDmVP-OG6Ik9rLL4J3qHZKdPr-Uz8IfayxD6QzUh26RnvNtRZBbTEtWprUCoxLkjJL6s6dwfRpMKsCOFIg8KWnuI9d6xt8dVAk0uTBXvHfM4LVHTfut18x5i-M9spBadskjvsXWjEWL4yVNHXe7j00vSWe1YmXYbD2nw7Uvkrn8NWAmmLeLxZNwQYsQ8q4FOX4FNVRxOwRM4yYV_4KTqeI1dvqXmK5s3p7VQnzLDkcMNLucGReys-mrFwuuEVf8gPx7LGLQlpNq2ZC60EdsJyrH607zP0f6c7pXw?type=png)](https://mermaid.live/edit#pako:eNplUsluwjAQ_ZWRz_ADObQCEiggOLAc2iQHN56ABbGjsU2FAv_erBBBLs7Yb5lnT8ESLZB5LD3rv-TIycLOjxSU3yjc7kabnQcbtCTxgrDEa84lxTAcfsC42BskyElfpEADXAhCU65KgJEHxa0j_Lw3WuOKcvtGc4NJ-NBDldA1tyjg1ChDSjqDmVP-OG6Ik9rLL4J3qHZKdPr-Uz8IfayxD6QzUh26RnvNtRZBbTEtWprUCoxLkjJL6s6dwfRpMKsCOFIg8KWnuI9d6xt8dVAk0uTBXvHfM4LVHTfut18x5i-M9spBadskjvsXWjEWL4yVNHXe7j00vSWe1YmXYbD2nw7Uvkrn8NWAmmLeLxZNwQYsQ8q4FOX4FNVRxOwRM4yYV_4KTqeI1dvqXmK5s3p7VQnzLDkcMNLucGReys-mrFwuuEVf8gPx7LGLQlpNq2ZC60EdsJyrH607zP0f6c7pXw)
-
-## CORE FUNCTIONS
+// Configure with explicit RPC URL and private key
+await setSigner(
+    "https://your-rpc-url", 
+    "your-private-key"
+);
 
-- `verifySignature(message, signature)`: Verifies an Ethereum signature for a given message.
+// Get the configured signer
+const signer = await getSigner();
+```
 
-  ```javascript
-  const recoveredAddress = await gun.verifySignature(message, signature);
-  ```
+2. **MetaMask Fallback (Development-Friendly)**
+```javascript
+import { getSigner } from 'gun-eth';
+
+// Will automatically use MetaMask if available
+try {
+    const signer = await getSigner();
+    console.log("Connected with address:", await signer.getAddress());
+} catch (error) {
+    console.error("No valid provider found");
+}
+```
 
-- `generatePassword(signature)`: Generates a password from an Ethereum signature.
+The signer selection follows these priorities:
+1. Uses manually configured signer if set via `setSigner()`
+2. Falls back to MetaMask if available and no manual configuration
+3. Throws an error if no valid provider is found
 
-  ```javascript
-  const password = gun.generatePassword(signature);
-  ```
+### Error Handling
 
-- `createSignature(message)`: Creates an Ethereum signature for a message.
+```javascript
+try {
+    const gunEth = await GunEth.init({
+        gun,
+        chain: 'localhost'
+    });
+} catch (error) {
+    console.error('Initialization error:', error);
+}
+```
 
-  ```javascript
-  const signature = await gun.createSignature(message);
-  ```
+## 📚 Documentation
 
-- `createAndStoreEncryptedPair(address, signature)`: Creates and stores an encrypted key pair.
+### 🔐 Gun-Ethereum Integration
 
-  ```javascript
-  await gun.createAndStoreEncryptedPair(address, signature);
-  ```
+#### ETH -> GUN Conversion
+```javascript
+try {
+    // Create signature with Ethereum wallet
+    const signature = await GunEth.createSignature(GunEth.MESSAGE_TO_SIGN);
+    
+    // Convert to Gun SEA compatible keypair
+    const gunKeyPair = await GunEth.ethToGunAccount(signature);
+    
+    console.log('Generated Gun SEA keypair:', gunKeyPair);
+    // The keypair contains keys generated by Gun SEA:
+    // {
+    //     pub: "SEA-public-key",
+    //     priv: "SEA-private-key",
+    //     epub: "SEA-encryption-public-key",
+    //     epriv: "SEA-encryption-private-key"
+    // }
+} catch (error) {
+    console.error('Conversion error:', error);
+}
+```
 
-- `getAndDecryptPair(address, signature)`: Retrieves and decrypts a stored key pair.
+#### GUN -> ETH Conversion
+```javascript
+try {
+    // Requires the SEA private key generated by Gun
+    const ethAccount = await GunEth.gunToEthAccount(gunSEAPrivateKey);
+    console.log('Ethereum account:', ethAccount);
+} catch (error) {
+    console.error('Conversion error:', error);
+}
+```
 
-  ```javascript
-  const decryptedPair = await gun.getAndDecryptPair(address, signature);
-  ```
+### 🔒 Stealth Chain
 
-- `shine(chain, nodeId, data, callback)`: Implements SHINE for data verification and storage on the blockchain.
+```javascript
+// Initialize Gun
+const gun = Gun();
+await GunEth.init({ gun, chain: 'localhost' });
+
+try {
+    // Publish stealth keys
+    const signature = await GunEth.createSignature(GunEth.MESSAGE_TO_SIGN);
+    await gun.publishStealthKeys(signature);
+
+    // Generate stealth address
+    const stealthInfo = await gun.generateStealthAddress(
+        recipientAddress,
+        signature,
+        {} // Additional options if needed
+    );
+
+    console.log('Generated stealth address:', stealthInfo);
+    // Returns:
+    // {
+    //     stealthAddress: "0x...",      // The generated stealth address
+    //     senderPublicKey: "...",       // The sender's public key
+    //     spendingPublicKey: "..."      // The recipient's spending public key
+    // }
+
+    // Announce the payment
+    await gun.announceStealthPayment(
+        stealthInfo.stealthAddress,
+        stealthInfo.senderPublicKey,
+        stealthInfo.spendingPublicKey,
+        signature,
+        { onChain: true } // Optional: announce on-chain
+    );
+} catch (error) {
+    console.error('Stealth operation error:', error);
+}
+
+// Monitor stealth events
+gun.monitorStealthEvents((event) => {
+    console.log('New stealth event:', event);
+});
+```
 
-  ```javascript
-  gun.shine("optimismSepolia", nodeId, data, callback);
-  ```
-  
-## SHINE
+### ⛓️ Proof Chain
 
-SHINE (Secure Hash Integrity Network Ethereum) provides a mechanism for verifying data integrity using Ethereum and Gun.js.
+```javascript
+try {
+    // Write data with proof
+    await gun.proof('users', null, {
+        name: 'Alice',
+        age: 25
+    }, (ack) => {
+        if (ack.err) {
+            console.error('Write error:', ack.err);
+            return;
+        }
+        console.log('Data written successfully:', {
+            nodeId: ack.nodeId,
+            txHash: ack.txHash
+        });
+    });
+
+    // Verify data integrity
+    await gun.proof('users', 'nodeId123', null, (ack) => {
+        if (ack.err) {
+            console.error('Verification error:', ack.err);
+            return;
+        }
+        console.log('Verification completed:', ack.ok);
+    });
+} catch (error) {
+    console.error('Proof operation error:', error);
+}
+```
 
+### 🫧 Encrypted Bubbles
 
-[![](https://mermaid.ink/img/pako:eNplk1GTmjAQx79KJs_oICAiD9epQoX25Dq1006LPqRkPTMHiRODdx763S8Ez7N3PCXZ__73txvS4EJQwCFel-Kx2BCp0M9oyZH-PucL1e4XSZrF6BdItmYFUUzwFer1btCkSfm2ViHi2iGln05d2qQNHv_A7oim-Q9QksEeECWKoLUUFZrVPJqsOu3UGEVNZKKi5heX6M0lzuMnJUmhUCG4Aq4SstusrmWZOKIvecxpiIwTF6pzO6tiU2aWmx4OHYvgPd0u42fJzEiSjmRPSkYvilek5A0pzWegUEkU7BSSUAhJu-b-laJ4uPZNLoBf3wHuzUDhlTE1AN-uRO8E19Nt_W41AwepGRCHx_MlnLW3xmyeTyW08Y9zmxtBpm9YSECM_3crmQne5b8l08mCf-zqzii-d7CZrm5GumvN6ApbuAJZEUb1b9W0CUusNlDBEod6SYl8WGJzzE9aS2olFgde4FDJGiwsRX2_weGalDu9q7faGiJG7iWpLqdbwnHY4Ccc9pxxf-wEA9exPc92A384tPABh8NB33WDwdCxfcfxAy84WfhZCG0x6HuuZ49HI98PRjpojywMlGn2efcSzIMwNf6ahBbr9AJRuPoz?type=png)](https://mermaid.live/edit#pako:eNplk1GTmjAQx79KJs_oICAiD9epQoX25Dq1006LPqRkPTMHiRODdx763S8Ez7N3PCXZ__73txvS4EJQwCFel-Kx2BCp0M9oyZH-PucL1e4XSZrF6BdItmYFUUzwFer1btCkSfm2ViHi2iGln05d2qQNHv_A7oim-Q9QksEeECWKoLUUFZrVPJqsOu3UGEVNZKKi5heX6M0lzuMnJUmhUCG4Aq4SstusrmWZOKIvecxpiIwTF6pzO6tiU2aWmx4OHYvgPd0u42fJzEiSjmRPSkYvilek5A0pzWegUEkU7BSSUAhJu-b-laJ4uPZNLoBf3wHuzUDhlTE1AN-uRO8E19Nt_W41AwepGRCHx_MlnLW3xmyeTyW08Y9zmxtBpm9YSECM_3crmQne5b8l08mCf-zqzii-d7CZrm5GumvN6ApbuAJZEUb1b9W0CUusNlDBEod6SYl8WGJzzE9aS2olFgde4FDJGiwsRX2_weGalDu9q7faGiJG7iWpLqdbwnHY4Ccc9pxxf-wEA9exPc92A384tPABh8NB33WDwdCxfcfxAy84WfhZCG0x6HuuZ49HI98PRjpojywMlGn2efcSzIMwNf6ahBbr9AJRuPoz)
+```javascript
+// Initialize Bubble Client
+import { BubbleClient } from 'gun-eth';
+
+const bubbleClient = new BubbleClient({
+    providerUrl: "http://localhost:3000/api",
+    signer: signer,  // Your Ethereum signer
+    keypair: {       // Your encryption keypair
+        epub: "your-encryption-public-key",
+        epriv: "your-encryption-private-key"
+    }
+});
 
+// Create and manage bubbles
+const bubble = await bubbleClient.createBubble("My Bubble", {
+    isPrivate: true
+});
 
+// Write encrypted content
+await bubbleClient.writeBubble(
+    bubble.id,
+    "secret.txt",
+    "My secret content"
+);
+
+// Read and decrypt content
+const result = await bubbleClient.readBubble(
+    bubble.id,
+    "secret.txt"
+);
+
+// Share with another user
+await bubbleClient.shareBubble(
+    bubble.id,
+    recipientAddress,
+    { granteeEpub: recipientPublicKey }
+);
+```
 
-#### SHINE Contract Configuration
+### 🔄 Bubble Providers
 
-Currently, SHINE supports only the Optimism Sepolia network. The contract address is managed internally:
+Gun-ETH offers three types of providers for managing encrypted bubbles:
 
+#### Base Provider
 ```javascript
-const SHINE_OPTIMISM_SEPOLIA = "0x43D838b683F772F08f321E5FA265ad3e333BE9C2";
+import { BaseBubbleProvider } from 'gun-eth';
+
+class CustomProvider extends BaseBubbleProvider {
+    async handleCreateBubble(options) { }
+    async handleWriteBubble(bubbleId, fileName, content) { }
+    async handleReadBubble(bubbleId, fileName) { }
+    async handleGrantPermission(bubbleId, granteeAddress) { }
+}
 ```
 
-To support other chains in the future, the plugin will select the appropriate address based on the `chain` parameter provided to the `shine` function.
+#### GUN Provider
+```javascript
+import { GUNBubbleProvider } from 'gun-eth';
 
-#### SHINE Helper Functions
+const gunProvider = new GUNBubbleProvider({
+    gun: gunInstance,
+    signer: signer,
+    keypair: keypair
+});
 
-SHINE uses several internal helper functions to interact with the blockchain:
+// Stores data directly in GUN's graph
+await gunProvider.handleCreateBubble({
+    name: "GUN Bubble",
+    isPrivate: true
+});
+```
+
+#### Hybrid Provider
+```javascript
+import { HybridBubbleProvider } from 'gun-eth';
 
-- `getSigner()`: Retrieves an Ethereum signer from the browser provider (e.g., MetaMask).
-- `verifyOnChain(nodeId, contentHash)`: Verifies data integrity on the blockchain.
-- `writeOnChain(nodeId, contentHash)`: Writes the content hash to the blockchain.
-- `getLatestRecord(nodeId)`: Retrieves the latest record associated with a nodeId from the blockchain.
+const hybridProvider = new HybridBubbleProvider({
+    gun: gunInstance,
+    signer: signer,
+    keypair: keypair,
+    storage: customStorageAdapter
+});
 
-These functions are used internally by the `shine` method and are not directly exposed to the user.
+// Supports both GUN and external storage
+await hybridProvider.handleCreateBubble({
+    name: "Hybrid Bubble",
+    isPrivate: true,
+    useExternal: true
+});
+```
 
-### Usage Examples
+### 📋 Templates
 
-#### Verifying Data by NodeId
+Gun-ETH provides ready-to-use templates for common implementations:
 
+#### Client Template
 ```javascript
-const nodeId = "your-node-id-here";
-
-gun.shine("optimismSepolia", nodeId, null, (ack) => {
-  if (ack.ok) {
-    console.log("Data verified on blockchain", ack);
-    console.log("Timestamp:", ack.timestamp);
-    console.log("Updater:", ack.updater);
-    console.log("Latest Record:", ack.latestRecord);
-  } else {
-    console.log("Data not verified or not found", ack);
-  }
-});
+// template-bubble-client.js
+const CONFIG = {
+    RPC_URL: process.env.RPC_URL,
+    PRIVATE_KEY: process.env.PRIVATE_KEY,
+    PROVIDER_URL: "http://localhost:3000/api",
+    GUN_PEERS: ['http://localhost:8765/gun'],
+    DECRYPTED_FILES_DIR: './decrypted-files'
+};
+
+// Initialize client with configuration
+const client = await initializeClient();
+
+// Example usage
+const bubble = await client.createBubble("Test Bubble");
+await client.writeBubble(bubble.id, "test.txt", "content");
+const result = await client.readBubble(bubble.id, "test.txt");
 ```
 
-#### Storing New Data
-
+#### Provider Template
 ```javascript
-const data = { message: "Hello, blockchain!" };
-
-gun.shine("optimismSepolia", null, data, (ack) => {
-  if (ack.ok) {
-    console.log("Data stored on Gun.js and blockchain", ack);
-    console.log("New Node ID:", ack.nodeId);
-    console.log("Transaction Hash:", ack.txHash);
-  } else {
-    console.log("Error storing data", ack);
-  }
-});
+// template-bubble-provider.js
+const CONFIG = {
+    RPC_URL: process.env.RPC_URL,
+    PRIVATE_KEY: process.env.PRIVATE_KEY,
+    GUN_PEERS: "http://localhost:8765/gun",
+    GUN_DIR: "radata",
+    BUBBLES_DIR: "bubbles"
+};
+
+// Initialize provider with configuration
+const app = express();
+const gun = Gun(gunOptions);
+const provider = new HybridBubbleProvider(CONFIG);
+
+// API endpoints
+app.post('/bubble', handleCreateBubble);
+app.post('/bubble/:id/write', handleWriteBubble);
+app.get('/bubble/:id', handleReadBubble);
 ```
 
-## STANDALONE MODE
+## 🏗️ Architecture
 
-For users who want to run the plugin without a browser wallet, you can use the standalone mode. This requires setting up an RPC URL and a private key:
+Gun-ETH is structured in independent modules:
 
-```javascript
-gun.setStandaloneConfig("https://your-rpc-url", "your-private-key");
-```
+- **Core**: Base functionality and Gun.js integration
+- **Stealth**: Private transaction implementation
+- **Proof**: Verification and anchoring system
+- **Crypto**: Cryptographic utilities
+- **Utils**: Common support functions
+
+## 🌟 Features
 
-Make sure to keep your private key secure and never expose it in client-side code.
+### Secure Backup System
+- End-to-end encryption
+- Version control
+- Decentralized storage
 
-### Security Considerations
+### Advanced Privacy
+- Stealth transactions
+- Private communications
+- On-chain announcements
 
-- Use a secure Ethereum provider (e.g., MetaMask) when interacting with functions that require signatures.
-- Generated passwords and key pairs are sensitive. Handle them carefully and avoid exposing them.
-- Keep Gun.js and Ethereum dependencies up to date for security.
-- Be aware of gas costs associated with blockchain interactions when using SHINE.
+### Data Integrity
+- Cryptographic verification
+- Blockchain anchoring
+- Change monitoring
 
-## Contributing
+### Web3 Integration
+- Seamless Gun/Ethereum account conversion
+- Signature and authentication support
+- Complete key management
 
-We welcome contributions! Please open an issue or submit a pull request on GitHub.
+## 🤝 Contributing
 
-## License
+Contributions are welcome! Please:
 
-This project is released under the MIT license.
+1. 🍴 Fork the repository
+2. 🌿 Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. 💾 Commit your changes (`git commit -m 'Add: amazing feature'`)
+4. 📤 Push to the branch (`git push origin feature/AmazingFeature`)
+5. 🔄 Open a Pull Request
 
-## Contact
+## 📄 License
 
-For questions or support, please open an issue on GitHub: https://github.com/scobru/gun-eth
+MIT © 2024 Scobru