Business Meets Innovation

// This very portfolio! Built with Astro + Three.js + AI
import * as THREE from 'three';
import { gsap } from 'gsap';

class CoinMorphAnimation {
  constructor(container: HTMLElement) {
    this.scene = new THREE.Scene();
    this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
    this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
    
    this.setupScene();
    this.createCoin();
    this.createNeuralNetwork();
    this.animate();
  }
  
  createCoin() {
    const geometry = new THREE.CylinderGeometry(1, 1, 0.1, 32);
    const material = new THREE.MeshPhongMaterial({
      color: 0xed7611, // Moroccan orange
      shininess: 100
    });
    
    this.coin = new THREE.Mesh(geometry, material);
    this.scene.add(this.coin);
  }
  
  morphToNeuralNetwork() {
    gsap.timeline()
      .to(this.coin.scale, { duration: 1, x: 0.1, y: 0.1, z: 0.1 })
      .to(this.coin.material, { duration: 0.5, opacity: 0 }, "-=0.5")
      .call(() => this.showNeuralNetwork());
  }
}

# Natural Language Processing for Moroccan Arabic (Darija)
import spacy
from transformers import AutoTokenizer, AutoModel
import torch

class MoroccanNLP:
    def __init__(self):
        self.tokenizer = AutoTokenizer.from_pretrained('aubmindlab/bert-base-arabertv2')
        self.model = AutoModel.from_pretrained('aubmindlab/bert-base-arabertv2')
        
    def analyze_sentiment(self, text: str) -> dict:
        """Analyze sentiment of Moroccan Arabic text"""
        # Preprocess Darija text
        processed_text = self.preprocess_darija(text)
        
        # Tokenize and encode
        inputs = self.tokenizer(processed_text, return_tensors='pt', 
                               padding=True, truncation=True, max_length=512)
        
        with torch.no_grad():
            outputs = self.model(**inputs)
            
        # Extract sentiment features
        embeddings = outputs.last_hidden_state.mean(dim=1)
        sentiment_score = torch.sigmoid(embeddings).item()
        
        return {
            'sentiment': 'positive' if sentiment_score > 0.6 else 'negative' if sentiment_score < 0.4 else 'neutral',
            'confidence': abs(sentiment_score - 0.5) * 2,
            'score': sentiment_score
        }
    
    def preprocess_french(self, text: str) -> str:
        """Preprocess French financial text"""
        # Handle common French financial expressions
        french_mappings = {
            'bénéfice': 'profit',
            'chiffre d'affaires': 'revenue',
            'trésorerie': 'cash_flow',
        }

        for french, standard in french_mappings.items():
            text = text.replace(french, standard)

        return text

# Example usage
nlp = MoroccanNLP()
result = nlp.analyze_sentiment("هاد الشي زوين بزاف!")
print(f"Sentiment: {result['sentiment']} (confidence: {result['confidence']:.2f})")

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MoroccanRemittance is ReentrancyGuard, Ownable {
    struct Transfer {
        address sender;
        address recipient;
        uint256 amount;
        uint256 fee;
        string currency;
        uint256 timestamp;
        bool completed;
    }
    
    mapping(uint256 => Transfer) public transfers;
    mapping(address => bool) public authorizedAgents;
    
    uint256 public transferCounter;
    uint256 public feePercentage = 150; // 1.5%
    
    event TransferInitiated(uint256 indexed transferId, address indexed sender, 
                           address indexed recipient, uint256 amount);
    event TransferCompleted(uint256 indexed transferId);
    
    modifier onlyAuthorizedAgent() {
        require(authorizedAgents[msg.sender], "Not authorized agent");
        _;
    }
    
    function initiateTransfer(
        address _recipient,
        string memory _currency
    ) external payable nonReentrant {
        require(msg.value > 0, "Amount must be greater than 0");
        require(_recipient != address(0), "Invalid recipient");
        
        uint256 fee = (msg.value * feePercentage) / 10000;
        uint256 transferAmount = msg.value - fee;
        
        transferCounter++;
        
        transfers[transferCounter] = Transfer({
            sender: msg.sender,
            recipient: _recipient,
            amount: transferAmount,
            fee: fee,
            currency: _currency,
            timestamp: block.timestamp,
            completed: false
        });
        
        emit TransferInitiated(transferCounter, msg.sender, _recipient, transferAmount);
    }
    
    function completeTransfer(uint256 _transferId) 
        external 
        onlyAuthorizedAgent 
        nonReentrant 
    {
        Transfer storage transfer = transfers[_transferId];
        require(!transfer.completed, "Transfer already completed");
        require(transfer.amount > 0, "Invalid transfer");
        
        transfer.completed = true;
        
        // Transfer funds to recipient
        payable(transfer.recipient).transfer(transfer.amount);
        
        emit TransferCompleted(_transferId);
    }
    
    function addAuthorizedAgent(address _agent) external onlyOwner {
        authorizedAgents[_agent] = true;
    }
    
    function setFeePercentage(uint256 _feePercentage) external onlyOwner {
        require(_feePercentage <= 500, "Fee too high"); // Max 5%
        feePercentage = _feePercentage;
    }
}