@fairblock/stabletrust 2.0.6 → 2.0.10

package/src/vendor/ts-ibe/crypto/ibe.js

@@ -0,0 +1,198 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import * as bls from "@noble/bls12-381";
+import { utils } from "@noble/bls12-381";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToNumberBE, fp12ToBytes, xor } from "./utils.js";
+import { Buffer } from "buffer";
+export function encryptOnG1(master, ID, msg) {
+    return __awaiter(this, void 0, void 0, function () {
+        var Qid, Gid, sigma, r, U, rGid, hrGid, V, hsigma, W;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (msg.length >> 8 > 1) {
+                        throw new Error("cannot encrypt messages larger than our hash output: 256 bits.");
+                    }
+                    return [4 /*yield*/, bls.PointG2.hashToCurve(ID)];
+                case 1:
+                    Qid = _a.sent();
+                    Gid = bls.pairing(master, Qid);
+                    sigma = utils.randomBytes(msg.length);
+                    r = h3(sigma, msg);
+                    U = bls.PointG1.BASE.multiply(r);
+                    rGid = Gid.pow(r);
+                    return [4 /*yield*/, gtToHash(rGid, msg.length)];
+                case 2:
+                    hrGid = _a.sent();
+                    V = xor(sigma, hrGid);
+                    hsigma = h4(sigma, msg.length);
+                    W = xor(msg, hsigma);
+                    return [2 /*return*/, {
+                            U: U,
+                            V: V,
+                            W: W,
+                        }];
+            }
+        });
+    });
+}
+export function encryptOnG2(master, ID, msg) {
+    return __awaiter(this, void 0, void 0, function () {
+        var Qid, Gid, sigma, r, U, rGid, hrGid, V, hsigma, W;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (msg.length >> 8 > 1) {
+                        throw new Error("cannot encrypt messages larger than our hash output: 256 bits.");
+                    }
+                    return [4 /*yield*/, bls.PointG1.hashToCurve(ID)];
+                case 1:
+                    Qid = _a.sent();
+                    Gid = bls.pairing(Qid, master);
+                    sigma = utils.randomBytes(msg.length);
+                    r = h3(sigma, msg);
+                    U = bls.PointG2.BASE.multiply(r);
+                    rGid = Gid.pow(r);
+                    return [4 /*yield*/, gtToHash(rGid, msg.length)];
+                case 2:
+                    hrGid = _a.sent();
+                    V = xor(sigma, hrGid);
+                    hsigma = h4(sigma, msg.length);
+                    W = xor(msg, hsigma);
+                    return [2 /*return*/, {
+                            U: U,
+                            V: V,
+                            W: W,
+                        }];
+            }
+        });
+    });
+}
+export function decryptOnG1(p, c) {
+    return __awaiter(this, void 0, void 0, function () {
+        var gidt, hgidt, sigma, hsigma, msg, r, rP;
+        return __generator(this, function (_a) {
+            gidt = bls.pairing(c.U, p);
+            hgidt = gtToHash(gidt, c.W.length);
+            if (hgidt.length != c.V.length) {
+                throw new Error("XorSigma is of invalid length");
+            }
+            sigma = xor(hgidt, c.V);
+            hsigma = h4(sigma, c.W.length);
+            msg = xor(hsigma, c.W);
+            r = h3(sigma, msg);
+            rP = bls.PointG1.BASE.multiply(r);
+            if (!rP.equals(c.U)) {
+                throw new Error("invalid proof: rP check failed");
+            }
+            return [2 /*return*/, msg];
+        });
+    });
+}
+export function decryptOnG2(p, c) {
+    return __awaiter(this, void 0, void 0, function () {
+        var gidt, hgidt, sigma, hsigma, msg, r, rP;
+        return __generator(this, function (_a) {
+            gidt = bls.pairing(p, c.U);
+            hgidt = gtToHash(gidt, c.W.length);
+            if (hgidt.length != c.V.length) {
+                throw new Error("XorSigma is of invalid length");
+            }
+            sigma = xor(hgidt, c.V);
+            hsigma = h4(sigma, c.W.length);
+            msg = xor(hsigma, c.W);
+            r = h3(sigma, msg);
+            rP = bls.PointG2.BASE.multiply(r);
+            if (!rP.equals(c.U)) {
+                throw new Error("invalid proof: rP check failed");
+            }
+            return [2 /*return*/, msg];
+        });
+    });
+}
+export function gtToHash(gt, len) {
+    return sha256
+        .create()
+        .update("IBE-H2")
+        .update(fp12ToBytes(gt))
+        .digest()
+        .slice(0, len);
+}
+// Our IBE hashes
+var BitsToMaskForBLS12381 = 1;
+function h3(sigma, msg) {
+    var h3ret = sha256
+        .create()
+        .update("IBE-H3")
+        .update(sigma)
+        .update(msg)
+        .digest();
+    // We will hash iteratively: H(i || H("IBE-H3" || sigma || msg)) until we get a
+    // value that is suitable as a scalar.
+    for (var i = 1; i < 65535; i++) {
+        var data = h3ret;
+        data = sha256
+            .create()
+            .update(create16BitUintBuffer(i))
+            .update(data)
+            .digest();
+        // assuming Big Endianness
+        data[0] = data[0] >> BitsToMaskForBLS12381;
+        var n = bytesToNumberBE(data);
+        if (n < bls.CURVE.r) {
+            return n;
+        }
+    }
+    throw new Error("invalid proof: rP check failed");
+}
+function h4(sigma, len) {
+    var h4sigma = sha256.create().update("IBE-H4").update(sigma).digest();
+    return h4sigma.slice(0, len);
+}
+function create16BitUintBuffer(input) {
+    if (input < 0) {
+        throw Error("cannot write a negative value as uint!");
+    }
+    if (input > Math.pow(2, 16)) {
+        throw Error("input value too large to fit in a uint16!");
+    }
+    var buf = Buffer.alloc(2);
+    buf.writeUint16LE(input);
+    return buf;
+}
+//# sourceMappingURL=ibe.js.map

package/src/vendor/ts-ibe/crypto/utils.js

@@ -0,0 +1,50 @@
+import { Buffer } from "buffer";
+// returns a new array with the xor of a ^ b
+export function xor(a, b) {
+    if (a.length != b.length) {
+        throw new Error("Error: incompatible sizes");
+    }
+    var ret = new Uint8Array(a.length);
+    for (var i = 0; i < a.length; i++) {
+        ret[i] = a[i] ^ b[i];
+    }
+    return ret;
+}
+// code from Noble:
+// https://github.com/paulmillr/noble-bls12-381/blob/6380415f1b7e5078c8883a5d8d687f2dd3bff6c2/index.ts#L132-L145
+export function bytesToNumberBE(uint8a) {
+    return BigInt("0x" + bytesToHex(Uint8Array.from(uint8a)));
+}
+var hexes = Array.from({ length: 256 }, function (v, i) {
+    return i.toString(16).padStart(2, "0");
+});
+export function bytesToHex(uint8a) {
+    // pre-caching chars could speed this up 6x.
+    var hex = "";
+    for (var i = 0; i < uint8a.length; i++) {
+        hex += hexes[uint8a[i]];
+    }
+    return hex;
+}
+////// end of code from Noble.
+// Function to convert Noble's FPs to byte arrays compatible with Kilic library.
+// weirdly all the child FPs have to be reversed when serialising to bytes
+export function fpToBytes(fp) {
+    // 48 bytes = 96 hex bytes
+    var hex = BigInt(fp.value).toString(16).padStart(96, "0");
+    var buf = Buffer.alloc(hex.length / 2);
+    buf.write(hex, "hex");
+    return buf;
+}
+export function fp2ToBytes(fp2) {
+    return Buffer.concat([fp2.c1, fp2.c0].map(fpToBytes));
+}
+// fp6 isn't exported by noble... let's take off the guard rails
+// eslint-disable-next-line  @typescript-eslint/no-explicit-any
+export function fp6ToBytes(fp6) {
+    return Buffer.concat([fp6.c2, fp6.c1, fp6.c0].map(fp2ToBytes));
+}
+export function fp12ToBytes(fp12) {
+    return Buffer.concat([fp12.c1, fp12.c0].map(fp6ToBytes));
+}
+//# sourceMappingURL=utils.js.map

package/src/vendor/ts-ibe/index.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { PointG1 } from "@noble/bls12-381";
+import * as ibe from "./crypto/ibe.js";
+import { encryptAge } from "./age/age-encrypt-decrypt.js";
+import { Buffer } from "buffer";
+function createTimelockEncrypter(id, pubKey) {
+    var _this = this;
+    return function (fileKey) { return __awaiter(_this, void 0, void 0, function () {
+        var idByte, point, ciphertext;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    idByte = new TextEncoder().encode(id);
+                    point = PointG1.fromHex(pubKey);
+                    return [4 /*yield*/, ibe.encryptOnG1(point, idByte, fileKey)];
+                case 1:
+                    ciphertext = _a.sent();
+                    return [2 /*return*/, [
+                            {
+                                type: "distIBE",
+                                args: ["".concat(id)],
+                                body: serialisedCiphertext(ciphertext),
+                            },
+                        ]];
+            }
+        });
+    }); };
+}
+function serialisedCiphertext(ciphertext) {
+    return Buffer.concat([
+        ciphertext.U.toRawBytes(true),
+        ciphertext.V,
+        ciphertext.W,
+    ]);
+}
+export function timelockEncrypt(identity, pubKey, payload) {
+    return __awaiter(this, void 0, void 0, function () {
+        var timelockEncrypter, agePayload, hexPayload;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    timelockEncrypter = createTimelockEncrypter(identity, pubKey);
+                    return [4 /*yield*/, encryptAge(payload, timelockEncrypter)];
+                case 1:
+                    agePayload = _a.sent();
+                    hexPayload = Buffer.from(agePayload, "binary").toString("hex");
+                    return [2 /*return*/, hexPayload];
+            }
+        });
+    });
+}
+//# sourceMappingURL=index.js.map

package/src/vendor/ts-ibe/types/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/src/vendor/ts-ibe/version.js

@@ -0,0 +1,2 @@
+export var TS_IBE_VERSION = "1.1.3";
+//# sourceMappingURL=version.js.map

package/src/wasm-loader.js

@@ -50,7 +50,7 @@ export async function initializeWasm(input) {
 
       if (input) {
         // User provided custom input
-        await init(input);
+        await init({ module_or_path: input });
       } else if (isNode) {
         // Node.js: Load from filesystem
         const fs = await import("fs");
@@ -65,11 +65,11 @@ export async function initializeWasm(input) {
         );
         const wasmBuffer = fs.readFileSync(wasmPath);
 
-        await init(wasmBuffer);
+        await init({ module_or_path: wasmBuffer });
       } else {
         // Browser: Let the generated code handle it automatically
         // It will use new URL(..., import.meta.url) which bundlers handle correctly
-        await init();
+        await init({ module_or_path: undefined });
       }
 
       isInitialized = true;

package/pkg/README.md

@@ -1,310 +0,0 @@
-# Confidential Tokens - Privacy-First Digital Assets
-
-A complete implementation of confidential token operations using ElGamal encryption and zero-knowledge proofs. This project includes both a Solidity smart contract (GatewayContract) and a professional web frontend for confidential token management.
-
-## 🚀 Features
-
-### Smart Contract (GatewayContract.sol)
-- **Account Management**: Create and manage confidential accounts with ElGamal keypairs
-- **Token Conversion**: Convert ERC20 tokens to confidential tokens
-- **Private Transfers**: Transfer confidential tokens with zero-knowledge proofs
-- **Secure Withdrawals**: Convert confidential tokens back to ERC20 tokens
-- **Access Control**: Role-based permissions for admin and relayer operations
-- **Event Logging**: Comprehensive event system for tracking operations
-
-### Frontend Application
-- **Professional UI**: Modern, responsive design optimized for real-world usage
-- **Wallet Integration**: MetaMask connection for Ethereum blockchain access
-- **Account Dashboard**: View encrypted balances and account status
-- **Token Operations**: Convert, transfer, and withdraw confidential tokens
-- **Client-Side Security**: All cryptographic operations performed in WebAssembly
-- **Real-Time Updates**: Live status updates and transaction tracking
-
-## 🏗️ Architecture
-
-```
-┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
-│   Frontend      │    │  GatewayContract │    │   Relayer       │
-│   (Web App)     │◄──►│   (Solidity)     │◄──►│   (Off-chain)   │
-│                 │    │                  │    │                 │
-│ • MetaMask      │    │ • Account Mgmt   │    │ • Proof Verify  │
-│ • WebAssembly   │    │ • Token Escrow   │    │ • State Update  │
-│ • Proof Gen     │    │ • Event Logging  │    │ • Balance Mgmt  │
-└─────────────────┘    └──────────────────┘    └─────────────────┘
-```
-
-## 📁 Project Structure
-
-```
-elgamal-demo/
-├── GatewayContract.sol          # Main smart contract
-├── src/                         # Rust cryptographic library
-│   ├── components/              # Core cryptographic components
-│   │   ├── elgamal.rs          # ElGamal encryption implementation
-│   │   ├── proofs.rs           # Zero-knowledge proofs
-│   │   └── ...
-│   ├── transfer.rs             # Transfer proof generation
-│   ├── withdraw.rs             # Withdraw proof generation
-│   └── lib.rs                  # Library exports
-├── frontend/                    # Web application
-│   ├── index.html              # Main application page
-│   ├── styles.css              # Professional styling
-│   ├── app.js                  # Main application logic
-│   ├── deployment-config.js    # Configuration file
-│   ├── src/lib.rs              # WebAssembly bindings
-│   └── pkg/                    # Built WebAssembly files
-└── scripts/                     # Deployment scripts
-```
-
-## 🛠️ Installation & Setup
-
-### Prerequisites
-- **Rust**: Latest stable version
-- **Node.js**: 16+ with npm
-- **Solidity**: For smart contract development
-- **MetaMask**: Browser extension for wallet connection
-
-### 1. Clone and Setup
-
-```bash
-git clone <repository-url>
-cd elgamal-demo
-
-# Install Rust dependencies
-cargo build
-
-# Setup frontend
-cd frontend
-npm install
-npm run build:wasm
-```
-
-### 2. Smart Contract Deployment
-
-```bash
-# Deploy GatewayContract (example using Hardhat)
-npx hardhat compile
-npx hardhat run scripts/deploy.js --network <network>
-```
-
-### 3. Configuration
-
-Update `frontend/deployment-config.js` with your deployed contract address and network settings:
-
-```javascript
-export const CONFIG = {
-    GATEWAY_CONTRACT_ADDRESS: '0xYourDeployedContractAddress',
-    NETWORK: {
-        chainId: 1, // Mainnet or testnet
-        name: 'Ethereum Mainnet',
-        // ... other settings
-    }
-};
-```
-
-### 4. Start Development Server
-
-```bash
-cd frontend
-npm run dev
-# Open http://localhost:8080
-```
-
-## 🔧 Usage
-
-### 1. Connect Wallet
-- Click "Connect Wallet" in the header
-- Approve MetaMask connection
-- Verify your address is displayed
-
-### 2. Create Confidential Account
-- Click "Create Account" card
-- Generate ElGamal keypair (stored locally)
-- Submit account creation to contract
-
-### 3. Convert Tokens
-- Select token (USDC, USDT, DAI)
-- Enter amount to convert
-- Approve token transfer and confirm conversion
-
-### 4. Private Transfers
-- Enter recipient address
-- Select token and amount
-- Generate zero-knowledge proof
-- Submit confidential transfer
-
-### 5. Withdraw Tokens
-- Select token and amount
-- Generate withdrawal proof
-- Convert back to ERC20 tokens
-
-## 🔐 Security Features
-
-### Cryptographic Security
-- **ElGamal Encryption**: All balances encrypted with user-specific keys
-- **Zero-Knowledge Proofs**: Transfer amounts and balances remain private
-- **Client-Side Generation**: All proofs generated locally in WebAssembly
-- **No Server Dependency**: Cryptographic operations don't require server trust
-
-### Smart Contract Security
-- **Access Control**: Role-based permissions for sensitive operations
-- **Reentrancy Protection**: Guards against reentrancy attacks
-- **Pausable Operations**: Admin can pause contract in emergencies
-- **Event Logging**: Comprehensive audit trail for all operations
-
-### Frontend Security
-- **Local Key Storage**: Private keys stored in browser (use secure storage in production)
-- **Input Validation**: All user inputs validated before processing
-- **Error Handling**: Comprehensive error handling and user feedback
-- **HTTPS Required**: All operations require secure connections
-
-## 🌐 Network Support
-
-### Mainnet
-- Ethereum Mainnet
-- Token addresses for USDC, USDT, DAI
-
-### Testnet
-- Sepolia Testnet
-- Test token addresses
-- Faucet integration for testing
-
-## 📊 API Reference
-
-### WebAssembly Functions
-
-```javascript
-// Generate ElGamal keypair
-const keypair = await generate_keypair();
-
-// Encrypt amount with public key
-const encrypted = await encrypt_amount(amount, pubkey);
-
-// Generate transfer proof
-const proof = await generate_transfer_proof({
-    current_balance_ciphertext,
-    current_balance,
-    transfer_amount,
-    source_keypair,
-    destination_pubkey
-});
-
-// Generate withdraw proof
-const proof = await generate_withdraw_proof({
-    current_balance_ciphertext,
-    current_balance,
-    withdraw_amount,
-    keypair
-});
-```
-
-### Smart Contract Functions
-
-```solidity
-// Create confidential account
-function createConfidentialAccount(bytes calldata elgamalPubkey) 
-    external returns (bytes32);
-
-// Convert tokens to confidential
-function deposit(DepositItem[] calldata items) 
-    external returns (bytes32);
-
-// Private transfer
-function transferConfidential(address recipient, string calldata denom, bytes calldata transferProofData) 
-    external returns (bytes32);
-
-// Withdraw tokens
-function withdraw(string calldata denom, uint256 amount, bytes calldata withdrawProofData) 
-    external returns (bytes32);
-```
-
-## 🚀 Deployment
-
-### Frontend Deployment (Vercel)
-
-```bash
-# Install Vercel CLI
-npm i -g vercel
-
-# Deploy
-cd frontend
-vercel --prod
-```
-
-### Smart Contract Deployment
-
-```bash
-# Using Hardhat
-npx hardhat run scripts/deploy.js --network mainnet
-
-# Using Foundry
-forge create --rpc-url <RPC_URL> --private-key <PRIVATE_KEY> GatewayContract
-```
-
-## 🔍 Testing
-
-### Frontend Testing
-
-```bash
-cd frontend
-npm test
-```
-
-### Smart Contract Testing
-
-```bash
-npx hardhat test
-```
-
-### WebAssembly Testing
-
-```bash
-cd frontend
-npm run test:wasm
-```
-
-## 📝 Development
-
-### Adding New Features
-
-1. **Smart Contract**: Add functions to `GatewayContract.sol`
-2. **Cryptography**: Implement in Rust library (`src/`)
-3. **WebAssembly**: Expose functions in `frontend/src/lib.rs`
-4. **Frontend**: Add UI components in `app.js`
-
-### Code Style
-
-- **Rust**: Follow standard Rust conventions
-- **JavaScript**: Use ES6+ features, async/await
-- **Solidity**: Follow OpenZeppelin patterns
-- **CSS**: Use CSS custom properties for theming
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit changes (`git commit -m 'Add amazing feature'`)
-4. Push to branch (`git push origin feature/amazing-feature`)
-5. Open Pull Request
-
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## 🆘 Support
-
-- **Issues**: Report bugs and feature requests on GitHub Issues
-- **Discussions**: Join community discussions on GitHub Discussions
-- **Documentation**: Check the [USAGE.md](frontend/USAGE.md) for detailed usage guide
-
-## 🔮 Roadmap
-
-- [ ] Multi-asset support
-- [ ] Batch operations
-- [ ] Mobile app
-- [ ] Advanced privacy features
-- [ ] Integration with other DeFi protocols
-
----
-
-**Built with ❤️ for privacy and decentralization**