Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Blockchain

Ethereum Smart Contracts with Solidity

Comprehensive Ethereum smart contract development examples including ERC-20, ERC-721, DeFi protocols, and hardware wallet integration

Samples

Entries inside this sample collection

CodesoliditySimple

Solidity Fundamentals and Basic Smart Contract

Core Solidity concepts, data types, functions, modifiers, events, and a complete simple smart contract example

Difficulty

4/10

Estimated time

30 min

Tags

solidity, basics, smart-contracts, ethereum

Prerequisites

Basic programming concepts, Blockchain fundamentals

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

// Basic Solidity Concepts and Data Types
contract SolidityBasics {

    // State Variables
    uint256 public myNumber = 42;
    string public myString = "Hello, Solidity!";
    bool public myBool = true;
    address public owner;

    // Integer Types
    int256 public myInt = -100;
    uint8 public smallUint = 255;
    uint256 public largeUint;

    // Fixed Size Arrays
    uint256[5] public fixedArray = [1, 2, 3, 4, 5];
    address[3] public addressArray;

    // Dynamic Arrays
    uint256[] public dynamicArray;
    string[] public stringArray;

    // Mappings (Key-Value Pairs)
    mapping(address => uint256) public balances;
    mapping(string => address) public names;

    // Structs (Custom Data Types)
    struct Person {
        string name;
        uint256 age;
        bool isStudent;
    }

    Person public defaultPerson;
    mapping(address => Person) public people;

    // Enums (Limited Set of Values)
    enum State { Created, Locked, Inactive }
    State public currentState;

    // Constants and Immutables
    uint256 public constant MAX_SUPPLY = 1000000;
    address public immutable CREATOR;

    // Events
    event NumberChanged(uint256 oldValue, uint256 newValue);
    event PersonAdded(address indexed personAddress, string name, uint256 age);
    event StateChanged(State oldState, State newState);
    event EtherReceived(address indexed from, uint256 amount);

    // Modifiers
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    modifier validAddress(address _addr) {
        require(_addr != address(0), "Invalid address");
        _;
    }

    modifier costs(uint256 amount) {
        require(msg.value >= amount, "Not enough ether sent");
        _;
    }

    // Constructor (runs once during deployment)
    constructor() {
        owner = msg.sender;
        CREATOR = msg.sender;
        defaultPerson = Person("Default", 25, false);
        currentState = State.Created;
    }

    // Basic Functions
    function setNumber(uint256 _newNumber) public {
        uint256 oldValue = myNumber;
        myNumber = _newNumber;
        emit NumberChanged(oldValue, _newNumber);
    }

    function getNumber() public view returns (uint256) {
        return myNumber;
    }

    function addPerson(string memory _name, uint256 _age) public validAddress(msg.sender) {
        people[msg.sender] = Person(_name, _age, false);
        emit PersonAdded(msg.sender, _name, _age);
    }

    function getPerson(address _addr) public view returns (string memory name, uint256 age, bool isStudent) {
        Person memory person = people[_addr];
        return (person.name, person.age, person.isStudent);
    }

    // Array Operations
    function addToDynamicArray(uint256 _value) public {
        dynamicArray.push(_value);
    }

    function getDynamicArrayLength() public view returns (uint256) {
        return dynamicArray.length;
    }

    function getDynamicArrayElement(uint256 _index) public view returns (uint256) {
        require(_index < dynamicArray.length, "Index out of bounds");
        return dynamicArray[_index];
    }

    // Mapping Operations
    function setBalance(address _addr, uint256 _amount) public {
        balances[_addr] = _amount;
    }

    function getBalance(address _addr) public view returns (uint256) {
        return balances[_addr];
    }

    // State Management
    function changeState(State _newState) public onlyOwner {
        State oldState = currentState;
        currentState = _newState;
        emit StateChanged(oldState, _newState);
    }

    // Ether Handling
    function deposit() public payable {
        require(msg.value > 0, "Must send ether");
        emit EtherReceived(msg.sender, msg.value);
    }

    function withdraw(uint256 _amount) public onlyOwner {
        require(address(this).balance >= _amount, "Insufficient contract balance");
        payable(owner).transfer(_amount);
    }

    // Get contract balance
    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    // Fallback function to receive ether
    receive() external payable {
        emit EtherReceived(msg.sender, msg.value);
    }

    // Fallback function for unknown function calls
    fallback() external payable {
        emit EtherReceived(msg.sender, msg.value);
    }
}

// Advanced Example: Simple Voting Contract
contract SimpleVoting {

    struct Candidate {
        string name;
        uint256 voteCount;
        bool exists;
    }

    mapping(string => Candidate) public candidates;
    mapping(address => bool) public hasVoted;

    string[] public candidateNames;
    uint256 public votingEndTime;
    bool public votingActive;

    event VoteCast(address indexed voter, string candidateName);
    event CandidateAdded(string candidateName);
    event VotingStarted(uint256 endTime);
    event VotingEnded();

    modifier onlyWhileActive() {
        require(votingActive && block.timestamp < votingEndTime, "Voting is not active");
        _;
    }

    modifier onlyOnce() {
        require(!hasVoted[msg.sender], "You have already voted");
        _;
    }

    constructor() {
        votingActive = false;
    }

    function addCandidate(string memory _name) public {
        require(!candidates[_name].exists, "Candidate already exists");
        require(bytes(_name).length > 0, "Candidate name cannot be empty");

        candidates[_name] = Candidate({
            name: _name,
            voteCount: 0,
            exists: true
        });

        candidateNames.push(_name);
        emit CandidateAdded(_name);
    }

    function startVoting(uint256 _durationInMinutes) public {
        require(!votingActive, "Voting is already active");
        require(candidateNames.length >= 2, "Need at least 2 candidates");

        votingActive = true;
        votingEndTime = block.timestamp + (_durationInMinutes * 60);
        emit VotingStarted(votingEndTime);
    }

    function vote(string memory _candidateName) public onlyWhileActive onlyOnce {
        require(candidates[_candidateName].exists, "Candidate does not exist");

        candidates[_candidateName].voteCount++;
        hasVoted[msg.sender] = true;

        emit VoteCast(msg.sender, _candidateName);
    }

    function endVoting() public {
        require(votingActive, "Voting is not active");
        require(block.timestamp >= votingEndTime, "Voting period has not ended");

        votingActive = false;
        emit VotingEnded();
    }

    function getWinner() public view returns (string memory winnerName, uint256 winnerVotes) {
        require(!votingActive, "Voting is still active");

        uint256 maxVotes = 0;
        winnerName = "No candidates";

        for (uint256 i = 0; i < candidateNames.length; i++) {
            string memory name = candidateNames[i];
            if (candidates[name].voteCount > maxVotes) {
                maxVotes = candidates[name].voteCount;
                winnerName = name;
            }
        }

        winnerVotes = maxVotes;
    }

    function getCandidateInfo(string memory _name) public view returns (string memory, uint256, bool) {
        return (
            candidates[_name].name,
            candidates[_name].voteCount,
            candidates[_name].exists
        );
    }

    function getTotalCandidates() public view returns (uint256) {
        return candidateNames.length;
    }
}

// Library Example: SafeMath
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        return c;
    }
}

// Example using the SafeMath library
contract BankAccount {
    using SafeMath for uint256;

    mapping(address => uint256) public balances;

    event Deposit(address indexed from, uint256 amount);
    event Withdrawal(address indexed to, uint256 amount);

    function deposit() public payable {
        require(msg.value > 0, "Must deposit ether");
        balances[msg.sender] = balances[msg.sender].add(msg.value);
        emit Deposit(msg.sender, msg.value);
    }

    function withdraw(uint256 _amount) public {
        require(_amount <= balances[msg.sender], "Insufficient balance");
        balances[msg.sender] = balances[msg.sender].sub(_amount);
        payable(msg.sender).transfer(_amount);
        emit Withdrawal(msg.sender, _amount);
    }

    function getBalance() public view returns (uint256) {
        return balances[msg.sender];
    }
}
CodesolidityIntermediate

ERC-20 Token Standard Implementation

Complete ERC-20 token contract with minting, burning, pausing, and advanced features like voting rights and time-locked transfers

Difficulty

7/10

Estimated time

45 min

Tags

erc20, token, solidity, ethereum, smart-contracts

Prerequisites

Solidity basics, ERC-20 standard, Token economics

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

// Interface for ERC-20 Token Standard
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// OpenZeppelin's SafeMath library for safe arithmetic operations
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        return c;
    }
}

// Advanced ERC-20 Token Contract with Additional Features
contract AdvancedERC20Token is IERC20 {
    using SafeMath for uint256;

    // Token Metadata
    string public name;
    string public symbol;
    uint8 public decimals;

    // Token State Variables
    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    // Ownership
    address public owner;
    address public minter;

    // Pausable Feature
    bool public paused = false;

    // Time-locked Transfers
    mapping(address => uint256) public lockedUntil;
    mapping(address => uint256) public lockAmount;

    // Blacklist
    mapping(address => bool) public blacklisted;

    // Vesting Schedule
    struct VestingSchedule {
        uint256 totalAmount;
        uint256 releasedAmount;
        uint256 startTime;
        uint256 duration;
        bool isActive;
    }

    mapping(address => VestingSchedule) public vestingSchedules;

    // Voting Rights
    mapping(address => uint256) public votingPower;
    uint256 public totalVotingPower;

    // Events
    event TokensMinted(address indexed to, uint256 amount);
    event TokensBurned(address indexed from, uint256 amount);
    event TokensLocked(address indexed account, uint256 amount, uint256 until);
    event TokensUnlocked(address indexed account, uint256 amount);
    event AccountBlacklisted(address indexed account);
    event AccountWhitelisted(address indexed account);
    event VestingCreated(address indexed beneficiary, uint256 amount, uint256 duration);
    event VestingClaimed(address indexed beneficiary, uint256 amount);
    event Pause();
    event Unpause();
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event MinterChanged(address indexed previousMinter, address indexed newMinter);

    // Modifiers
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    modifier onlyMinter() {
        require(msg.sender == minter || msg.sender == owner, "Only minter can call this function");
        _;
    }

    modifier whenNotPaused() {
        require(!paused, "Token contract is paused");
        _;
    }

    modifier notBlacklisted(address _account) {
        require(!blacklisted[_account], "Account is blacklisted");
        _;
    }

    modifier validAddress(address _account) {
        require(_account != address(0), "Invalid address");
        _;
    }

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        uint256 _initialSupply
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        owner = msg.sender;
        minter = msg.sender;

        if (_initialSupply > 0) {
            _mint(msg.sender, _initialSupply);
        }
    }

    // ERC-20 Standard Functions

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address to, uint256 amount) public override
        whenNotPaused
        notBlacklisted(msg.sender)
        notBlacklisted(to)
        validAddress(to)
        returns (bool) {

        _transfer(msg.sender, to, amount);
        return true;
    }

    function allowance(address owner, address spender) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public override
        whenNotPaused
        notBlacklisted(msg.sender)
        notBlacklisted(spender)
        validAddress(spender)
        returns (bool) {

        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public override
        whenNotPaused
        notBlacklisted(from)
        notBlacklisted(to)
        notBlacklisted(msg.sender)
        validAddress(to)
        returns (bool) {

        uint256 currentAllowance = _allowances[from][msg.sender];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");

        _transfer(from, to, amount);
        _approve(from, msg.sender, currentAllowance - amount);

        return true;
    }

    // Internal Functions

    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");

        // Check for locked tokens
        require(block.timestamp >= lockedUntil[from] || fromBalance - amount >= lockAmount[from],
               "ERC20: transfer of locked tokens");

        _balances[from] = fromBalance - amount;
        _balances[to] = _balances[to].add(amount);

        // Update voting power
        _updateVotingPower(from);
        _updateVotingPower(to);

        emit Transfer(from, to, amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _mint(address to, uint256 amount) internal {
        require(to != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[to] = _balances[to].add(amount);

        _updateVotingPower(to);

        emit Transfer(address(0), to, amount);
        emit TokensMinted(to, amount);
    }

    function _burn(address from, uint256 amount) internal {
        require(from != address(0), "ERC20: burn from the zero address");

        uint256 accountBalance = _balances[from];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");

        _balances[from] = accountBalance - amount;
        _totalSupply = _totalSupply - amount;

        _updateVotingPower(from);

        emit Transfer(from, address(0), amount);
        emit TokensBurned(from, amount);
    }

    function _updateVotingPower(address account) internal {
        uint256 newPower = _balances[account];
        uint256 oldPower = votingPower[account];

        votingPower[account] = newPower;
        totalVotingPower = totalVotingPower.sub(oldPower).add(newPower);
    }

    // Minting and Burning

    function mint(address to, uint256 amount) external onlyMinter validAddress(to) {
        require(to != address(0), "Cannot mint to zero address");
        _mint(to, amount);
    }

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    function burnFrom(address from, uint256 amount) external {
        uint256 currentAllowance = _allowances[from][msg.sender];
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");

        _burn(from, amount);
        _approve(from, msg.sender, currentAllowance - amount);
    }

    // Pausable Functions

    function pause() external onlyOwner {
        require(!paused, "Contract is already paused");
        paused = true;
        emit Pause();
    }

    function unpause() external onlyOwner {
        require(paused, "Contract is not paused");
        paused = false;
        emit Unpause();
    }

    // Ownership Management

    function transferOwnership(address newOwner) external onlyOwner validAddress(newOwner) {
        address oldOwner = owner;
        owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    function setMinter(address newMinter) external onlyOwner validAddress(newMinter) {
        address oldMinter = minter;
        minter = newMinter;
        emit MinterChanged(oldMinter, newMinter);
    }

    // Token Locking

    function lockTokens(uint256 amount, uint256 duration) external {
        require(amount <= _balances[msg.sender], "Insufficient balance to lock");

        lockAmount[msg.sender] = lockAmount[msg.sender].add(amount);
        lockedUntil[msg.sender] = lockedUntil[msg.sender].add(duration);

        emit TokensLocked(msg.sender, amount, lockedUntil[msg.sender]);
    }

    function unlockTokens() external {
        require(block.timestamp >= lockedUntil[msg.sender], "Tokens are still locked");
        require(lockAmount[msg.sender] > 0, "No tokens to unlock");

        uint256 amount = lockAmount[msg.sender];
        lockAmount[msg.sender] = 0;

        emit TokensUnlocked(msg.sender, amount);
    }

    // Blacklist Management

    function blacklist(address account) external onlyOwner validAddress(account) {
        blacklisted[account] = true;
        emit AccountBlacklisted(account);
    }

    function whitelist(address account) external onlyOwner validAddress(account) {
        blacklisted[account] = false;
        emit AccountWhitelisted(account);
    }

    // Vesting Functions

    function createVesting(
        address beneficiary,
        uint256 amount,
        uint256 duration
    ) external onlyMinter validAddress(beneficiary) {
        require(amount > 0, "Vesting amount must be greater than 0");
        require(duration > 0, "Vesting duration must be greater than 0");

        vestingSchedules[beneficiary] = VestingSchedule({
            totalAmount: amount,
            releasedAmount: 0,
            startTime: block.timestamp,
            duration: duration,
            isActive: true
        });

        _mint(beneficiary, amount);
        emit VestingCreated(beneficiary, amount, duration);
    }

    function claimVesting() external {
        VestingSchedule storage schedule = vestingSchedules[msg.sender];
        require(schedule.isActive, "No active vesting schedule");

        uint256 timePassed = block.timestamp - schedule.startTime;
        uint256 vestedAmount;

        if (timePassed >= schedule.duration) {
            vestedAmount = schedule.totalAmount;
        } else {
            vestedAmount = (schedule.totalAmount * timePassed) / schedule.duration;
        }

        uint256 claimableAmount = vestedAmount - schedule.releasedAmount;
        require(claimableAmount > 0, "No tokens to claim");

        schedule.releasedAmount = vestedAmount;

        if (timePassed >= schedule.duration) {
            schedule.isActive = false;
        }

        emit VestingClaimed(msg.sender, claimableAmount);
    }

    // View Functions

    function getVestingInfo(address beneficiary) external view returns (
        uint256 totalAmount,
        uint256 releasedAmount,
        uint256 vestedAmount,
        uint256 claimableAmount,
        uint256 startTime,
        uint256 duration,
        bool isActive
    ) {
        VestingSchedule memory schedule = vestingSchedules[beneficiary];

        uint256 timePassed = block.timestamp - schedule.startTime;
        uint256 _vestedAmount;

        if (timePassed >= schedule.duration) {
            _vestedAmount = schedule.totalAmount;
        } else {
            _vestedAmount = (schedule.totalAmount * timePassed) / schedule.duration;
        }

        uint256 _claimableAmount = _vestedAmount - schedule.releasedAmount;

        return (
            schedule.totalAmount,
            schedule.releasedAmount,
            _vestedAmount,
            _claimableAmount,
            schedule.startTime,
            schedule.duration,
            schedule.isActive
        );
    }

    function getLockedTokens(address account) external view returns (uint256 amount, uint256 until) {
        return (lockAmount[account], lockedUntil[account]);
    }

    // Batch Operations

    function batchTransfer(address[] calldata recipients, uint256[] calldata amounts)
        external
        whenNotPaused
        returns (bool) {

        require(recipients.length == amounts.length, "Arrays must have same length");
        require(recipients.length > 0, "Arrays cannot be empty");

        for (uint256 i = 0; i < recipients.length; i++) {
            require(recipients[i] != address(0), "Invalid recipient address");
            require(!blacklisted[recipients[i]], "Recipient is blacklisted");

            _transfer(msg.sender, recipients[i], amounts[i]);
        }

        return true;
    }

    function batchApprove(address[] calldata spenders, uint256[] calldata amounts)
        external
        whenNotPaused
        returns (bool) {

        require(spenders.length == amounts.length, "Arrays must have same length");
        require(spenders.length > 0, "Arrays cannot be empty");

        for (uint256 i = 0; i < spenders.length; i++) {
            require(spenders[i] != address(0), "Invalid spender address");
            require(!blacklisted[spenders[i]], "Spender is blacklisted");

            _approve(msg.sender, spenders[i], amounts[i]);
        }

        return true;
    }
}
CodesolidityIntermediate

ERC-721 NFT Contract with Metadata

Complete ERC-721 non-fungible token implementation with IPFS metadata, royalty system, and marketplace integration

Difficulty

8/10

Estimated time

50 min

Tags

erc721, nft, solidity, ethereum, smart-contracts

Prerequisites

Solidity basics, ERC-721 standard, IPFS, Metadata standards

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

// ERC-721 Non-Fungible Token Standard
interface IERC721 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function balanceOf(address owner) external view returns (uint256 balance);
    function ownerOf(uint256 tokenId) external view returns (address owner);
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    function setApprovalForAll(address operator, bool approved) external;
    function getApproved(uint256 tokenId) external view returns (address operator);
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// ERC-721 Metadata Extension
interface IERC721Metadata is IERC721 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// ERC-721 Enumerable Extension
interface IERC721Enumerable is IERC721 {
    function totalSupply() external view returns (uint256);
    function tokenByIndex(uint256 index) external view returns (uint256);
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}

// OpenZeppelin libraries
library Counters {
    struct Counter {
        uint256 _value;
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value > 0 ? counter._value - 1 : 0;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        return account.code.length > 0;
    }
}

library Strings {
    function toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }
}

// NFT Metadata Structure
struct NFTMetadata {
    string name;
    string description;
    string image;
    string external_url;
    string animation_url;
    string background_color;
    string youtube_url;
    Attribute[] attributes;
}

struct Attribute {
    string trait_type;
    string value;
    uint256 display_type; // 0: string, 1: number, 2: boost_percentage
}

// Royalty Structure
struct RoyaltyInfo {
    address recipient;
    uint256 percentage; // Percentage in basis points (10000 = 100%)
}

// Advanced ERC-721 NFT Contract
contract AdvancedNFT is IERC721, IERC721Metadata, IERC721Enumerable {
    using Counters for Counters.Counter;
    using Strings for uint256;
    using Address for address;

    // Token State Variables
    Counters.Counter private _tokenIdCounter;

    string private _name;
    string private _symbol;
    string private _baseTokenURI;

    // Mappings
    mapping(uint256 => address) private _owners;
    mapping(address => uint256) private _balances;
    mapping(uint256 => address) private _tokenApprovals;
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // Owner mappings for enumeration
    mapping(address => uint256[]) private _ownedTokens;
    mapping(uint256 => uint256) private _ownedTokensIndex;
    mapping(uint256 => uint256) private _allTokensIndex;
    uint256[] private _allTokens;

    // NFT-specific data
    mapping(uint256 => NFTMetadata) private _tokenMetadata;
    mapping(uint256 => RoyaltyInfo) private _royalties;
    mapping(uint256 => bool) private _exists;
    mapping(uint256 => bool) private _burned;

    // Contract metadata
    address public owner;
    address public minter;
    uint256 public maxSupply;
    uint256 public mintPrice;
    bool public mintingActive;

    // Marketplace integration
    mapping(uint256 => bool) public _forSale;
    mapping(uint256 => uint256) public _salePrice;
    mapping(uint256 => address) public _saleCurrency; // address(0) for ETH

    // Events
    event TokenMinted(address indexed to, uint256 indexed tokenId);
    event TokenBurned(uint256 indexed tokenId);
    event MetadataUpdated(uint256 indexed tokenId);
    event RoyaltySet(uint256 indexed tokenId, address recipient, uint256 percentage);
    event TokenListed(uint256 indexed tokenId, uint256 price, address currency);
    event TokenSold(uint256 indexed tokenId, address indexed from, address indexed to, uint256 price);
    event MintingStateChanged(bool active);
    event MintPriceChanged(uint256 newPrice);

    // Modifiers
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    modifier onlyMinter() {
        require(msg.sender == minter || msg.sender == owner, "Only minter can call this function");
        _;
    }

    modifier whenMintingActive() {
        require(mintingActive, "Minting is not active");
        _;
    }

    modifier validToken(uint256 tokenId) {
        require(_exists[tokenId] && !_burned[tokenId], "Token does not exist");
        _;
    }

    modifier onlyTokenOwner(uint256 tokenId) {
        require(ownerOf(tokenId) == msg.sender, "Only token owner can call this function");
        _;
    }

    constructor(
        string memory name_,
        string memory symbol_,
        string memory baseTokenURI_,
        uint256 maxSupply_,
        uint256 mintPrice_
    ) {
        _name = name_;
        _symbol = symbol_;
        _baseTokenURI = baseTokenURI_;
        maxSupply = maxSupply_;
        mintPrice = mintPrice_;
        owner = msg.sender;
        minter = msg.sender;
        mintingActive = false;
    }

    // ERC-721 Standard Functions

    function name() external view override returns (string memory) {
        return _name;
    }

    function symbol() external view override returns (string memory) {
        return _symbol;
    }

    function tokenURI(uint256 tokenId) external view override validToken(tokenId) returns (string memory) {
        string memory baseURI = _baseTokenURI;
        return bytes(baseURI).length > 0
            ? string(abi.encodePacked(baseURI, tokenId.toString()))
            : "";
    }

    function balanceOf(address owner) external view override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    function ownerOf(uint256 tokenId) public view override validToken(tokenId) returns (address) {
        return _owners[tokenId];
    }

    function approve(address to, uint256 tokenId) external override validToken(tokenId) {
        address owner = ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(msg.sender == owner || isApprovedForAll(owner, msg.sender),
               "ERC721: approve caller is not owner nor approved for all");

        _approve(to, tokenId);
    }

    function getApproved(uint256 tokenId) public view override validToken(tokenId) returns (address) {
        return _tokenApprovals[tokenId];
    }

    function setApprovalForAll(address operator, bool approved) external override {
        require(operator != msg.sender, "ERC721: approve to caller");
        _operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function isApprovedForAll(address owner, address operator) public view override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    function transferFrom(address from, address to, uint256 tokenId) external override validToken(tokenId) {
        require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: transfer caller is not owner nor approved");
        _transfer(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) external override {
        safeTransferFrom(from, to, tokenId, "");
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override validToken(tokenId) {
        require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, data);
    }

    // ERC-721 Enumerable Functions

    function totalSupply() public view override returns (uint256) {
        return _allTokens.length;
    }

    function tokenByIndex(uint256 index) public view override returns (uint256) {
        require(index < totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
        require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    // Internal Functions

    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    function _transfer(address from, address to, uint256 tokenId) internal validToken(tokenId) {
        require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        // Update owned tokens list
        _removeTokenFromOwnerEnumeration(from, tokenId);
        _addTokenToOwnerEnumeration(to, tokenId);

        emit Transfer(from, to, tokenId);
    }

    function _mint(address to, uint256 tokenId) internal {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists[tokenId], "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;
        _exists[tokenId] = true;

        _addTokenToOwnerEnumeration(to, tokenId);
        _addTokenToAllTokensEnumeration(tokenId);

        emit Transfer(address(0), to, tokenId);
    }

    function _burn(uint256 tokenId) internal validToken(tokenId) {
        address owner = ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        _burned[tokenId] = true;

        // Remove from owner enumeration
        _removeTokenFromOwnerEnumeration(owner, tokenId);
        // Note: Keep in _allTokens for totalSupply consistency

        emit Transfer(owner, address(0), tokenId);
        emit TokenBurned(tokenId);
    }

    function _approve(address to, uint256 tokenId) internal validToken(tokenId) {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }

    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
        require(_exists[tokenId], "ERC721: operator query for nonexistent token");
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch {
                return false;
            }
        }
        return true;
    }

    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal {
        // Can be overridden by child contracts
    }

    // Enumeration helpers
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = balanceOf(to);
        _ownedTokens[to].push(tokenId);
        _ownedTokensIndex[tokenId] = length;
    }

    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        uint256 lastTokenIndex = balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
            _ownedTokens[from][tokenIndex] = lastTokenId;
            _ownedTokensIndex[lastTokenId] = tokenIndex;
        }

        delete _ownedTokensIndex[tokenId];
        _ownedTokens[from].pop();
    }

    // NFT-specific Functions

    function mintNFT(address to, NFTMetadata memory metadata) external onlyMinter whenMintingActive returns (uint256) {
        require(_tokenIdCounter.current() < maxSupply, "Max supply reached");

        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();

        _mint(to, tokenId);
        _setTokenMetadata(tokenId, metadata);

        emit TokenMinted(to, tokenId);
        return tokenId;
    }

    function mintBatch(address to, uint256 amount, NFTMetadata[] memory metadata) external onlyMinter whenMintingActive returns (uint256[] memory) {
        require(_tokenIdCounter.current() + amount <= maxSupply, "Max supply reached");
        require(amount == metadata.length, "Metadata array length mismatch");

        uint256[] memory tokenIds = new uint256[](amount);

        for (uint256 i = 0; i < amount; i++) {
            uint256 tokenId = _tokenIdCounter.current();
            _tokenIdCounter.increment();

            _mint(to, tokenId);
            _setTokenMetadata(tokenId, metadata[i]);

            tokenIds[i] = tokenId;
            emit TokenMinted(to, tokenId);
        }

        return tokenIds;
    }

    function burn(uint256 tokenId) external onlyTokenOwner(tokenId) {
        _burn(tokenId);
    }

    function setTokenMetadata(uint256 tokenId, NFTMetadata memory metadata) external onlyTokenOwner(tokenId) {
        _setTokenMetadata(tokenId, metadata);
        emit MetadataUpdated(tokenId);
    }

    function _setTokenMetadata(uint256 tokenId, NFTMetadata memory metadata) internal {
        _tokenMetadata[tokenId] = metadata;
    }

    function getTokenMetadata(uint256 tokenId) external view validToken(tokenId) returns (NFTMetadata memory) {
        return _tokenMetadata[tokenId];
    }

    function setRoyalty(uint256 tokenId, address recipient, uint256 percentage) external onlyTokenOwner(tokenId) {
        require(percentage <= 10000, "Royalty percentage cannot exceed 100%");
        _royalties[tokenId] = RoyaltyInfo(recipient, percentage);
        emit RoyaltySet(tokenId, recipient, percentage);
    }

    function getRoyalty(uint256 tokenId) external view validToken(tokenId) returns (address recipient, uint256 percentage) {
        RoyaltyInfo memory royalty = _royalties[tokenId];
        return (royalty.recipient, royalty.percentage);
    }

    // Marketplace Functions

    function listForSale(uint256 tokenId, uint256 price, address currency) external onlyTokenOwner(tokenId) {
        _forSale[tokenId] = true;
        _salePrice[tokenId] = price;
        _saleCurrency[tokenId] = currency;
        emit TokenListed(tokenId, price, currency);
    }

    function removeFromSale(uint256 tokenId) external onlyTokenOwner(tokenId) {
        _forSale[tokenId] = false;
        _salePrice[tokenId] = 0;
        _saleCurrency[tokenId] = address(0);
    }

    function buyToken(uint256 tokenId) external payable validToken(tokenId) {
        require(_forSale[tokenId], "Token not for sale");
        address seller = ownerOf(tokenId);
        require(msg.sender != seller, "Cannot buy your own token");
        address currency = _saleCurrency[tokenId];
        uint256 price = _salePrice[tokenId];

        if (currency == address(0)) {
            require(msg.value >= price, "Insufficient ETH sent");
            payable(seller).transfer(price);
        }

        // Handle royalty
        (address royaltyRecipient, uint256 royaltyPercentage) = getRoyalty(tokenId);
        if (royaltyRecipient != address(0) && royaltyPercentage > 0) {
            uint256 royaltyAmount = (price * royaltyPercentage) / 10000;
            if (currency == address(0)) {
                payable(royaltyRecipient).transfer(royaltyAmount);
            }
        }

        _transfer(seller, msg.sender, tokenId);

        // Remove from sale
        _forSale[tokenId] = false;
        _salePrice[tokenId] = 0;
        _saleCurrency[tokenId] = address(0);

        emit TokenSold(tokenId, seller, msg.sender, price);
    }

    // View Functions

    function getSaleInfo(uint256 tokenId) external view returns (bool forSale, uint256 price, address currency) {
        return (_forSale[tokenId], _salePrice[tokenId], _saleCurrency[tokenId]);
    }

    function tokensOfOwner(address owner) external view returns (uint256[] memory) {
        uint256 balance = balanceOf(owner);
        uint256[] memory result = new uint256[](balance);
        for (uint256 i = 0; i < balance; i++) {
            result[i] = tokenOfOwnerByIndex(owner, i);
        }
        return result;
    }

    function exists(uint256 tokenId) external view returns (bool) {
        return _exists[tokenId] && !_burned[tokenId];
    }

    // Admin Functions

    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

    function setMintingActive(bool active) external onlyOwner {
        mintingActive = active;
        emit MintingStateChanged(active);
    }

    function setMintPrice(uint256 newPrice) external onlyOwner {
        mintPrice = newPrice;
        emit MintPriceChanged(newPrice);
    }

    function setMinter(address newMinter) external onlyOwner {
        minter = newMinter;
    }

    function transferOwnership(address newOwner) external onlyOwner {
        owner = newOwner;
    }

    // Emergency Functions

    function emergencyWithdraw() external onlyOwner {
        payable(owner).transfer(address(this).balance);
    }
}

// Interface for ERC721 Receiver
interface IERC721Receiver {
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
CodesolidityComplex

DeFi Automated Market Maker (AMM) Protocol

Complete AMM implementation with liquidity pools, swap functionality, yield farming, and governance tokens

Difficulty

9/10

Estimated time

60 min

Tags

defi, amm, liquidity, yield-farming, solidity

Prerequisites

Advanced Solidity, DeFi concepts, Mathematical modeling, Gas optimization

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

// Interfaces for DeFi protocols
interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
}

interface IWETH is IERC20 {
    function deposit() external payable;
    function withdraw(uint256 amount) external;
}

// Library for safe math operations
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        return c;
    }
}

// Library for Uniswap-style calculations
library UniswapV2Library {
    using SafeMath for uint256;

    // Minimum amount out calculation
    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) internal pure returns (uint256 amountOut) {
        require(amountIn > 0, "UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT");
        require(reserveIn > 0 && reserveOut > 0, "UniswapV2Library: INSUFFICIENT_LIQUIDITY");

        uint256 numerator = amountIn.mul(reserveOut);
        uint256 denominator = reserveIn.add(amountIn);
        amountOut = numerator / denominator;
    }

    // Minimum amount in calculation
    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) internal pure returns (uint256 amountIn) {
        require(amountOut > 0, "UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT");
        require(reserveIn > 0 && reserveOut > 0, "UniswapV2Library: INSUFFICIENT_LIQUIDITY");

        uint256 numerator = reserveIn.mul(amountOut);
        uint256 denominator = reserveOut.sub(amountOut);
        amountIn = numerator / denominator;
    }

    // K calculation (constant product)
    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) internal pure returns (uint256 amountB) {
        require(amountA > 0, "UniswapV2Library: INSUFFICIENT_AMOUNT");
        require(reserveA > 0 && reserveB > 0, "UniswapV2Library: INSUFFICIENT_LIQUIDITY");

        amountB = amountA.mul(reserveB) / reserveA;
    }
}

// Liquidity Pool structure
struct LiquidityPool {
    address token0;
    address token1;
    uint256 reserve0;
    uint256 reserve1;
    uint256 totalLiquidity;
    address feeTo;
    uint256 feeNumerator; // Fee numerator (0-10000 basis points)
    bool initialized;
}

// Position structure for liquidity providers
struct Position {
    uint256 liquidity;
    uint256 token0Amount;
    uint256 token1Amount;
    uint256 lastUpdateTime;
    uint256 unclaimedFees0;
    uint256 unclaimedFees1;
}

// Farming position structure
struct FarmingPosition {
    uint256 amount;
    uint256 startTime;
    uint256 rewardDebt;
}

// Advanced AMM Protocol with Yield Farming
class AdvancedAMM {
    using SafeMath for uint256;
    using UniswapV2Library for uint256;

    // State variables
    address public owner;
    address public governanceToken;
    address public WETH;

    // Pools and positions
    mapping(bytes32 => LiquidityPool) public pools;
    mapping(address => mapping(bytes32 => Position)) public positions;
    mapping(address => mapping(bytes32 => FarmingPosition)) public farmingPositions;

    // Global state
    uint256 public totalValueLocked;
    uint256 public governanceRate; // Governance tokens per second

    // Fee configuration
    uint256 public protocolFeeNumerator = 3; // 0.3% protocol fee
    uint256 public liquidityProviderFeeNumerator = 25; // 0.25% LP fee

    // Events
    event PoolCreated(bytes32 indexed poolId, address indexed token0, address indexed token1);
    event LiquidityAdded(bytes32 indexed poolId, address indexed provider, uint256 amount0, uint256 amount1, uint256 liquidity);
    event LiquidityRemoved(bytes32 indexed poolId, address indexed provider, uint256 amount0, uint256 amount1, uint256 liquidity);
    event Swap(bytes32 indexed poolId, address indexed user, address tokenIn, uint256 amountIn, address tokenOut, uint256 amountOut);
    event FarmingPositionCreated(bytes32 indexed poolId, address indexed user, uint256 amount);
    event Harvested(bytes32 indexed poolId, address indexed user, uint256 governanceReward);

    // Modifiers
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    modifier validPool(bytes32 poolId) {
        require(pools[poolId].initialized, "Pool does not exist");
        _;
    }

    modifier validTokens(address token0, address token1) {
        require(token0 != address(0) && token1 != address(0), "Invalid token addresses");
        require(token0 != token1, "Tokens must be different");
        _;
    }

    constructor(address _governanceToken, address _WETH) {
        owner = msg.sender;
        governanceToken = _governanceToken;
        WETH = _WETH;
        governanceRate = 1 ether / (365 days); // 1 token per day distributed across all farms
    }

    // Pool management
    function createPool(address token0, address token1) external validTokens(token0, token1) returns (bytes32 poolId) {
        // Ensure tokens are in correct order (address ordering)
        if (token0 > token1) {
            (token0, token1) = (token1, token0);
        }

        poolId = keccak256(abi.encodePacked(token0, token1));

        require(!pools[poolId].initialized, "Pool already exists");

        pools[poolId] = LiquidityPool({
            token0: token0,
            token1: token1,
            reserve0: 0,
            reserve1: 0,
            totalLiquidity: 0,
            feeTo: msg.sender,
            feeNumerator: 30, // 0.3%
            initialized: true
        });

        emit PoolCreated(poolId, token0, token1);
        return poolId;
    }

    // Liquidity management
    function addLiquidity(
        bytes32 poolId,
        uint256 amount0Desired,
        uint256 amount1Desired,
        uint256 amount0Min,
        uint256 amount1Min,
        address to
    ) external payable validPool(poolId) returns (uint256 amount0, uint256 amount1, uint256 liquidity) {
        LiquidityPool storage pool = pools[poolId];

        // Handle ETH input
        if (pool.token0 == WETH || pool.token1 == WETH) {
            require(msg.value > 0, "Must send ETH for ETH pool");

            if (pool.token0 == WETH) {
                amount0Desired = msg.value;
                IWETH(WETH).deposit{value: msg.value}();
                IWETH(WETH).transfer(address(this), msg.value);
            } else {
                amount1Desired = msg.value;
                IWETH(WETH).deposit{value: msg.value}();
                IWETH(WETH).transfer(address(this), msg.value);
            }
        }

        // Calculate optimal amount if pool has no liquidity
        if (pool.reserve0 == 0 && pool.reserve1 == 0) {
            amount0 = amount0Desired;
            amount1 = amount1Desired;
        } else {
            uint256 amount1Optimal = amount0Desired.mul(pool.reserve1) / pool.reserve0;

            if (amount1Optimal <= amount1Desired) {
                require(amount1Optimal >= amount1Min, "Insufficient amount1");
                amount1 = amount1Optimal;
                amount0 = amount0Desired;
            } else {
                uint256 amount0Optimal = amount1Desired.mul(pool.reserve0) / pool.reserve1;
                require(amount0Optimal <= amount0Desired && amount0Optimal >= amount0Min, "Insufficient amount0");
                amount0 = amount0Optimal;
                amount1 = amount1Desired;
            }
        }

        // Transfer tokens from user
        if (pool.token0 != WETH) {
            IERC20(pool.token0).transferFrom(msg.sender, address(this), amount0);
        }
        if (pool.token1 != WETH) {
            IERC20(pool.token1).transferFrom(msg.sender, address(this), amount1);
        }

        // Calculate liquidity to mint
        if (pool.totalLiquidity == 0) {
            liquidity = amount0.mul(amount1).sqrt();
        } else {
            liquidity = amount0.mul(pool.totalLiquidity) / pool.reserve0;
        }

        // Update pool state
        pool.reserve0 = pool.reserve0.add(amount0);
        pool.reserve1 = pool.reserve1.add(amount1);
        pool.totalLiquidity = pool.totalLiquidity.add(liquidity);

        // Update user position
        Position storage position = positions[to][poolId];
        position.liquidity = position.liquidity.add(liquidity);
        position.token0Amount = position.token0Amount.add(amount0);
        position.token1Amount = position.token1Amount.add(amount1);
        position.lastUpdateTime = block.timestamp;

        totalValueLocked = totalValueLocked.add(amount0).add(amount1);

        emit LiquidityAdded(poolId, to, amount0, amount1, liquidity);
    }

    function removeLiquidity(
        bytes32 poolId,
        uint256 liquidity,
        uint256 amount0Min,
        uint256 amount1Min,
        address to
    ) external validPool(poolId) returns (uint256 amount0, uint256 amount1) {
        LiquidityPool storage pool = pools[poolId];
        Position storage position = positions[msg.sender][poolId];

        require(position.liquidity >= liquidity, "Insufficient liquidity");
        require(pool.totalLiquidity > 0, "No liquidity in pool");

        // Calculate amounts to receive
        amount0 = liquidity.mul(pool.reserve0) / pool.totalLiquidity;
        amount1 = liquidity.mul(pool.reserve1) / pool.totalLiquidity;

        require(amount0 >= amount0Min && amount1 >= amount1Min, "Slippage exceeded");

        // Update pool state
        pool.reserve0 = pool.reserve0.sub(amount0);
        pool.reserve1 = pool.reserve1.sub(amount1);
        pool.totalLiquidity = pool.totalLiquidity.sub(liquidity);

        // Update user position
        position.liquidity = position.liquidity.sub(liquidity);
        position.token0Amount = position.token0Amount.sub(amount0);
        position.token1Amount = position.token1Amount.sub(amount1);

        // Add unclaimed fees
        if (position.unclaimedFees0 > 0 || position.unclaimedFees1 > 0) {
            amount0 = amount0.add(position.unclaimedFees0);
            amount1 = amount1.add(position.unclaimedFees1);
            position.unclaimedFees0 = 0;
            position.unclaimedFees1 = 0;
        }

        // Transfer tokens to user
        if (pool.token0 == WETH) {
            IWETH(WETH).withdraw(amount0);
            payable(to).transfer(amount0);
        } else {
            IERC20(pool.token0).transfer(to, amount0);
        }

        if (pool.token1 == WETH) {
            IWETH(WETH).withdraw(amount1);
            payable(to).transfer(amount1);
        } else {
            IERC20(pool.token1).transfer(to, amount1);
        }

        totalValueLocked = totalValueLocked.sub(amount0).sub(amount1);

        emit LiquidityRemoved(poolId, msg.sender, amount0, amount1, liquidity);
    }

    // Swapping
    function swap(
        bytes32 poolId,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to
    ) external payable validPool(poolId) returns (uint256[] memory amounts) {
        LiquidityPool storage pool = pools[poolId];

        require(path.length >= 2, "Invalid path");

        // Handle ETH input
        uint256 ethAmount = 0;
        if (msg.value > 0) {
            require(pool.token0 == WETH || pool.token1 == WETH, "ETH not supported in this pool");
            ethAmount = msg.value;
            IWETH(WETH).deposit{value: ethAmount}();
            IWETH(WETH).transfer(address(this), ethAmount);
            amountIn = ethAmount;
        } else {
            // Transfer input token
            IERC20(path[0]).transferFrom(msg.sender, address(this), amountIn);
        }

        amounts = new uint256[](path.length);

        // Single pool swap
        if (path.length == 2) {
            amounts = _swapSinglePool(poolId, path[0], path[1], amountIn, to);
        } else {
            // Multi-hop swap (simplified)
            amounts = _swapMultiHop(path, amountIn, to);
        }

        require(amounts[amounts.length - 1] >= amountOutMin, "Slippage exceeded");

        // Refund unused ETH
        if (msg.value > 0 && ethAmount > 0) {
            uint256 refund = msg.value - ethAmount;
            if (refund > 0) {
                payable(msg.sender).transfer(refund);
            }
        }

        emit Swap(poolId, msg.sender, path[0], amounts[0], path[path.length - 1], amounts[amounts.length - 1]);
    }

    function _swapSinglePool(
        bytes32 poolId,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        address to
    ) internal returns (uint256[] memory amounts) {
        LiquidityPool storage pool = pools[poolId];

        require(
            (tokenIn == pool.token0 && tokenOut == pool.token1) ||
            (tokenIn == pool.token1 && tokenOut == pool.token0),
            "Invalid token pair"
        );

        uint256 reserve0 = pool.reserve0;
        uint256 reserve1 = pool.reserve1;

        require(reserve0 > 0 && reserve1 > 0, "Insufficient liquidity");

        uint256 amountOut;
        bool isToken0In = tokenIn == pool.token0;

        if (isToken0In) {
            amountOut = amountIn.getAmountOut(reserve0, reserve1);
            require(amountOut < reserve1, "Insufficient liquidity");

            pool.reserve0 = reserve0.add(amountIn);
            pool.reserve1 = reserve1.sub(amountOut);
        } else {
            amountOut = amountIn.getAmountOut(reserve1, reserve0);
            require(amountOut < reserve0, "Insufficient liquidity");

            pool.reserve1 = reserve1.add(amountIn);
            pool.reserve0 = reserve0.sub(amountOut);
        }

        // Transfer output token to user
        if (tokenOut == WETH) {
            IWETH(WETH).withdraw(amountOut);
            payable(to).transfer(amountOut);
        } else {
            IERC20(tokenOut).transfer(to, amountOut);
        }

        amounts = new uint256[](2);
        amounts[0] = amountIn;
        amounts[1] = amountOut;

        return amounts;
    }

    function _swapMultiHop(address[] calldata path, uint256 amountIn, address to) internal returns (uint256[] memory amounts) {
        // Simplified multi-hop implementation
        // In production, you'd implement proper multi-hop routing

        amounts = new uint256[](path.length);
        amounts[0] = amountIn;

        for (uint256 i = 0; i < path.length - 1; i++) {
            bytes32 poolId = _getPoolId(path[i], path[i + 1]);
            address nextRecipient = (i == path.length - 2) ? to : address(this);

            uint256[] memory hopAmounts = _swapSinglePool(poolId, path[i], path[i + 1], amounts[i], nextRecipient);
            amounts[i + 1] = hopAmounts[1];
        }

        return amounts;
    }

    // Yield farming
    function createFarmingPosition(bytes32 poolId, uint256 amount) external validPool(poolId) {
        Position storage position = positions[msg.sender][poolId];
        FarmingPosition storage farmingPosition = farmingPositions[msg.sender][poolId];

        require(position.liquidity >= amount, "Insufficient liquidity");

        // Update existing farming position or create new one
        if (farmingPosition.amount > 0) {
            _harvest(poolId, msg.sender);
        }

        farmingPosition.amount = farmingPosition.amount.add(amount);
        farmingPosition.startTime = block.timestamp;
        farmingPosition.rewardDebt = _calculatePendingRewards(poolId, msg.sender);

        emit FarmingPositionCreated(poolId, msg.sender, amount);
    }

    function harvest(bytes32 poolId) external validPool(poolId) {
        _harvest(poolId, msg.sender);
    }

    function _harvest(bytes32 poolId, address user) internal {
        FarmingPosition storage farmingPosition = farmingPositions[user][poolId];

        if (farmingPosition.amount == 0) return;

        uint256 pendingRewards = _calculatePendingRewards(poolId, user);
        require(pendingRewards > 0, "No rewards to harvest");

        farmingPosition.rewardDebt = farmingPosition.rewardDebt.add(pendingRewards);

        // Transfer governance tokens
        IERC20(governanceToken).transfer(user, pendingRewards);

        emit Harvested(poolId, user, pendingRewards);
    }

    function _calculatePendingRewards(bytes32 poolId, address user) internal view returns (uint256) {
        LiquidityPool storage pool = pools[poolId];
        FarmingPosition storage farmingPosition = farmingPositions[user][poolId];

        if (farmingPosition.amount == 0) return 0;

        uint256 timePassed = block.timestamp - farmingPosition.startTime;
        uint256 totalPoolLiquidity = pool.totalLiquidity;

        if (totalPoolLiquidity == 0) return 0;

        // Calculate rewards based on position size and time
        uint256 rewards = (governanceRate * timePassed * farmingPosition.amount) / totalPoolLiquidity;

        return rewards - farmingPosition.rewardDebt;
    }

    // Utility functions
    function _getPoolId(address token0, address token1) internal pure returns (bytes32) {
        if (token0 > token1) {
            (token0, token1) = (token1, token0);
        }
        return keccak256(abi.encodePacked(token0, token1));
    }

    function getPoolInfo(bytes32 poolId) external view returns (
        address token0,
        address token1,
        uint256 reserve0,
        uint256 reserve1,
        uint256 totalLiquidity,
        uint256 feeNumerator
    ) {
        LiquidityPool storage pool = pools[poolId];
        return (
            pool.token0,
            pool.token1,
            pool.reserve0,
            pool.reserve1,
            pool.totalLiquidity,
            pool.feeNumerator
        );
    }

    function getPosition(bytes32 poolId, address user) external view returns (
        uint256 liquidity,
        uint256 token0Amount,
        uint256 token1Amount,
        uint256 unclaimedFees0,
        uint256 unclaimedFees1
    ) {
        Position storage position = positions[user][poolId];
        return (
            position.liquidity,
            position.token0Amount,
            position.token1Amount,
            position.unclaimedFees0,
            position.unclaimedFees1
        );
    }

    function getFarmingPosition(bytes32 poolId, address user) external view returns (
        uint256 amount,
        uint256 startTime,
        uint256 pendingRewards
    ) {
        FarmingPosition storage farmingPosition = farmingPositions[user][poolId];
        uint256 rewards = _calculatePendingRewards(poolId, user);

        return (
            farmingPosition.amount,
            farmingPosition.startTime,
            rewards
        );
    }

    // sqrt function for liquidity calculation
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }

    // Admin functions
    function setGovernanceRate(uint256 newRate) external onlyOwner {
        governanceRate = newRate;
    }

    function setProtocolFee(uint256 newFeeNumerator) external onlyOwner {
        require(newFeeNumerator <= 1000, "Fee too high"); // Max 10%
        protocolFeeNumerator = newFeeNumerator;
    }

    function setLiquidityProviderFee(uint256 newFeeNumerator) external onlyOwner {
        require(newFeeNumerator <= 1000, "Fee too high"); // Max 10%
        liquidityProviderFeeNumerator = newFeeNumerator;
    }

    function emergencyWithdraw(address token, uint256 amount) external onlyOwner {
        if (token == address(0)) {
            payable(owner).transfer(amount);
        } else {
            IERC20(token).transfer(owner, amount);
        }
    }
}

// Math utilities for sqrt calculation
library Math {
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}
CodejavascriptComplex

Hardware Wallet Integration and Multi-Sig

Integration with Ledger and Trezor hardware wallets, multi-signature wallets, and secure key management

Difficulty

9/10

Estimated time

45 min

Tags

hardware-wallet, ledger, trezor, multi-sig, ethereum

Prerequisites

JavaScript, Ethereum, Web3, Hardware wallet concepts

javascript
// Hardware Wallet Integration with Ethereum
// Supports Ledger, Trezor, and other hardware wallets
// Implements multi-signature schemes and secure key management

const { ethers } = require('ethers');
const TransportWebHID = require('@ledgerhq/hw-transport-webhid');
const AppEth = require('@ledgerhq/hw-app-eth');
const TransportWebUSB = require('@ledgerhq/hw-transport-webusb');

// Hardware Wallet Manager Class
class HardwareWalletManager {
    constructor() {
        this.connectedWallets = new Map();
        this.supportedWallets = ['ledger', 'trezor', 'metamask', 'walletconnect'];
        this.currentProvider = null;
    }

    // Initialize connection with hardware wallet
    async connectHardwareWallet(walletType) {
        try {
            let transport;
            let wallet;

            switch (walletType.toLowerCase()) {
                case 'ledger':
                    transport = await this._connectLedger();
                    wallet = new AppEth(transport);
                    break;

                case 'trezor':
                    wallet = await this._connectTrezor();
                    break;

                default:
                    throw new Error(`Unsupported wallet type: ${walletType}`);
            }

            const address = await wallet.getAddress(0, false, false);
            const walletInfo = {
                type: walletType,
                address: address.address,
                wallet: wallet,
                transport: transport,
                connectedAt: new Date()
            };

            this.connectedWallets.set(walletType, walletInfo);
            return walletInfo;

        } catch (error) {
            throw new Error(`Failed to connect ${walletType}: ${error.message}`);
        }
    }

    // Connect to Ledger hardware wallet
    async _connectLedger() {
        try {
            // Try WebHID first (more modern)
            let transport = await TransportWebHID.create();

            // Fallback to WebUSB if WebHID fails
            if (!transport) {
                transport = await TransportWebUSB.create();
            }

            if (!transport) {
                throw new Error('Ledger device not found. Please unlock your device and ensure it\'s connected.');
            }

            return transport;
        } catch (error) {
            throw new Error(`Ledger connection failed: ${error.message}`);
        }
    }

    // Connect to Trezor hardware wallet
    async _connectTrezor() {
        try {
            const TrezorConnect = require('@trezor/connect-web');

            await TrezorConnect.init({
                lazyLoad: true,
                manifest: {
                    email: 'your-email@example.com',
                    appUrl: 'https://your-app-url.com'
                }
            });

            const result = await TrezorConnect.ethereumGetAddress({
                path: "m/44'/60'/0'/0/0",
                showOnDevice: true
            });

            if (!result.success) {
                throw new Error(result.payload.error);
            }

            return {
                type: 'trezor',
                address: result.payload.address,
                getBalance: this._getTrezorBalance.bind(this),
                signTransaction: this._signWithTrezor.bind(this),
                signMessage: this._signMessageWithTrezor.bind(this)
            };

        } catch (error) {
            throw new Error(`Trezor connection failed: ${error.message}`);
        }
    }

    // Get address from hardware wallet
    async getAddress(walletType, derivationPath = "m/44'/60'/0'/0/0") {
        const walletInfo = this.connectedWallets.get(walletType);
        if (!walletInfo) {
            throw new Error(`Wallet ${walletType} not connected`);
        }

        try {
            if (walletType === 'ledger') {
                const result = await walletInfo.wallet.getAddress(derivationPath, false, false);
                return result.address;
            } else if (walletType === 'trezor') {
                const TrezorConnect = require('@trezor/connect-web');
                const result = await TrezorConnect.ethereumGetAddress({
                    path: derivationPath,
                    showOnDevice: true
                });
                return result.payload.address;
            }
        } catch (error) {
            throw new Error(`Failed to get address from ${walletType}: ${error.message}`);
        }
    }

    // Sign transaction with hardware wallet
    async signTransaction(walletType, txData, chainId = 1) {
        const walletInfo = this.connectedWallets.get(walletType);
        if (!walletInfo) {
            throw new Error(`Wallet ${walletType} not connected`);
        }

        try {
            if (walletType === 'ledger') {
                return await this._signWithLedger(walletInfo.wallet, txData, chainId);
            } else if (walletType === 'trezor') {
                return await this._signWithTrezor(txData, chainId);
            }
        } catch (error) {
            throw new Error(`Failed to sign transaction with ${walletType}: ${error.message}`);
        }
    }

    // Sign with Ledger device
    async _signWithLedger(wallet, txData, chainId) {
        // Parse transaction data
        const ethersTx = ethers.utils.parseTransaction(txData);

        // Get derivation path
        const derivationPath = "m/44'/60'/0'/0/0";

        // Prepare signature data for Ledger
        const resolution = await wallet.resolveTransaction(
            ethersTx.raw,
            {
                erc20: true,
                nft: true
            }
        );

        // Sign transaction
        const signature = await wallet.signTransaction(
            derivationPath,
            ethersTx.raw,
            resolution
        );

        // Format signature for Ethereum
        const { v, r, s } = signature;

        // Create signed transaction
        const signedTx = ethers.utils.serializeTransaction({
            ...ethersTx,
            v: v,
            r: r,
            s: s
        });

        return signedTx;
    }

    // Sign with Trezor device
    async _signWithTrezor(txData, chainId) {
        const TrezorConnect = require('@trezor/connect-web');

        const ethersTx = ethers.utils.parseTransaction(txData);

        const result = await TrezorConnect.ethereumSignTransaction({
            path: "m/44'/60'/0'/0/0",
            transaction: {
                to: ethersTx.to,
                value: ethersTx.value.toString(),
                data: ethersTx.data || '',
                chainId: chainId,
                nonce: ethersTx.nonce,
                gasLimit: ethersTx.gasLimit.toString(),
                gasPrice: ethersTx.gasPrice?.toString() || '0',
                maxPriorityFeePerGas: ethersTx.maxPriorityFeePerGas?.toString() || null,
                maxFeePerGas: ethersTx.maxFeePerGas?.toString() || null
            }
        });

        if (!result.success) {
            throw new Error(result.payload.error);
        }

        // Combine signature components
        const signedTx = ethers.utils.serializeTransaction({
            ...ethersTx,
            v: parseInt(result.payload.v, 16),
            r: result.payload.r,
            s: result.payload.s
        });

        return signedTx;
    }

    // Sign message with hardware wallet
    async signMessage(walletType, message, derivationPath = "m/44'/60'/0'/0/0") {
        const walletInfo = this.connectedWallets.get(walletType);
        if (!walletInfo) {
            throw new Error(`Wallet ${walletType} not connected`);
        }

        try {
            if (walletType === 'ledger') {
                const messageHex = ethers.utils.hexlify(ethers.utils.toUtf8Bytes(message));
                const signature = await walletInfo.wallet.signPersonalMessage(
                    derivationPath,
                    messageHex
                );

                return {
                    signature: '0x' + signature.r + signature.s + signature.v.toString(16),
                    message: message,
                    address: await this.getAddress(walletType, derivationPath)
                };

            } else if (walletType === 'trezor') {
                const TrezorConnect = require('@trezor/connect-web');
                const result = await TrezorConnect.ethereumSignMessage({
                    path: derivationPath,
                    message: ethers.utils.hexlify(ethers.utils.toUtf8Bytes(message)),
                    hex: true
                });

                if (!result.success) {
                    throw new Error(result.payload.error);
                }

                return {
                    signature: result.payload.signature,
                    message: message,
                    address: result.payload.address
                };
            }
        } catch (error) {
            throw new Error(`Failed to sign message with ${walletType}: ${error.message}`);
        }
    }

    // Disconnect wallet
    async disconnectWallet(walletType) {
        const walletInfo = this.connectedWallets.get(walletType);
        if (walletInfo) {
            if (walletInfo.transport) {
                await walletInfo.transport.close();
            }
            this.connectedWallets.delete(walletType);
        }
    }

    // Get wallet info
    getWalletInfo(walletType) {
        const walletInfo = this.connectedWallets.get(walletType);
        if (walletInfo) {
            return {
                type: walletInfo.type,
                address: walletInfo.address,
                connectedAt: walletInfo.connectedAt
            };
        }
        return null;
    }

    // List all connected wallets
    listConnectedWallets() {
        const wallets = {};
        for (const [type, info] of this.connectedWallets) {
            wallets[type] = {
                type: info.type,
                address: info.address,
                connectedAt: info.connectedAt
            };
        }
        return wallets;
    }
}

// Multi-Signature Wallet Implementation
class MultiSigWallet {
    constructor(provider, contractAddress, owners, requiredSignatures = 2) {
        this.provider = provider;
        this.contractAddress = contractAddress;
        this.owners = owners;
        this.requiredSignatures = requiredSignatures;
        this.walletManager = new HardwareWalletManager();

        // Initialize contract interface
        this.contract = new ethers.Contract(
            contractAddress,
            MULTI_SIG_ABI,
            provider
        );
    }

    // Create transaction proposal
    async proposeTransaction(to, value, data, walletType) {
        try {
            // Get nonce for this wallet
            const nonce = await this.contract.nonce();

            // Create transaction data
            const txData = {
                to: to,
                value: value || '0',
                data: data || '0x',
                nonce: nonce
            };

            // Sign with hardware wallet
            const signature = await this.walletManager.signTransaction(walletType, txData);

            // Create proposal
            const proposal = {
                id: ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(
                    ['address', 'uint256', 'bytes', 'uint256'],
                    [to, value, data, nonce]
                )),
                to: to,
                value: value,
                data: data,
                nonce: nonce,
                signatures: [signature],
                proposers: [await this.walletManager.getAddress(walletType)]
            };

            return proposal;
        } catch (error) {
            throw new Error(`Failed to propose transaction: ${error.message}`);
        }
    }

    // Sign existing proposal
    async signProposal(proposal, walletType) {
        try {
            // Check if already signed
            const signerAddress = await this.walletManager.getAddress(walletType);
            if (proposal.signers && proposal.signers.includes(signerAddress)) {
                throw new Error('Already signed this proposal');
            }

            // Create signature
            const signature = await this.walletManager.signTransaction(walletType, {
                to: proposal.to,
                value: proposal.value,
                data: proposal.data,
                nonce: proposal.nonce
            });

            // Add signature to proposal
            proposal.signatures.push(signature);
            if (!proposal.signers) {
                proposal.signers = [];
            }
            proposal.signers.push(signerAddress);
            if (!proposal.proposers) {
                proposal.proposers = [];
            }
            proposal.proposers.push(signerAddress);

            return proposal;
        } catch (error) {
            throw new Error(`Failed to sign proposal: ${error.message}`);
        }
    }

    // Execute transaction if enough signatures collected
    async executeTransaction(proposal) {
        try {
            if (proposal.signatures.length < this.requiredSignatures) {
                throw new Error(`Need ${this.requiredSignatures} signatures, got ${proposal.signatures.length}`);
            }

            // Submit to multi-sig contract
            const tx = await this.contract.executeTransaction(
                proposal.to,
                proposal.value,
                proposal.data,
                proposal.signatures
            );

            return await tx.wait();
        } catch (error) {
            throw new Error(`Failed to execute transaction: ${error.message}`);
        }
    }
}

// Multi-Sig Contract ABI (simplified)
const MULTI_SIG_ABI = [
    "function executeTransaction(address to, uint256 value, bytes data, bytes[] signatures) external",
    "function nonce() view returns (uint256)",
    "function getOwners() view returns (address[])",
    "function getRequiredSignatures() view returns (uint256)"
];

// Example usage and testing functions
async function demonstrateHardwareWalletIntegration() {
    console.log('=== Hardware Wallet Integration Demo ===');

    const walletManager = new HardwareWalletManager();

    try {
        // Connect to Ledger
        console.log('\n1. Connecting to Ledger...');
        const ledgerInfo = await walletManager.connectHardwareWallet('ledger');
        console.log(`Connected to Ledger: ${ledgerInfo.address}`);

        // Connect to Trezor
        console.log('\n2. Connecting to Trezor...');
        const trezorInfo = await walletManager.connectHardwareWallet('trezor');
        console.log(`Connected to Trezor: ${trezorInfo.address}`);

        // Get balances
        console.log('\n3. Checking balances...');
        const provider = new ethers.providers.InfuraProvider('mainnet', process.env.INFURA_PROJECT_ID);

        const ledgerBalance = await provider.getBalance(ledgerInfo.address);
        const trezorBalance = await provider.getBalance(trezorInfo.address);

        console.log(`Ledger balance: ${ethers.utils.formatEther(ledgerBalance)} ETH`);
        console.log(`Trezor balance: ${ethers.utils.formatEther(trezorBalance)} ETH`);

        // Sign a message
        console.log('\n4. Signing messages...');
        const message = "Hello, Hardware Wallet!";

        const ledgerSignature = await walletManager.signMessage('ledger', message);
        console.log(`Ledger signature: ${ledgerSignature.signature}`);

        const trezorSignature = await walletManager.signMessage('trezor', message);
        console.log(`Trezor signature: ${trezorSignature.signature}`);

        // Create and sign a transaction (example)
        console.log('\n5. Creating and signing transactions...');
        const txData = {
            to: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
            value: ethers.utils.parseEther('0.001'),
            gasLimit: 21000,
            gasPrice: ethers.utils.parseUnits('20', 'gwei')
        };

        const ledgerTx = await walletManager.signTransaction('ledger', txData);
        console.log(`Ledger transaction signed: ${ledgerTx.substring(0, 50)}...`);

        // Multi-sig example
        console.log('\n6. Multi-signature wallet example...');
        const owners = [
            ledgerInfo.address,
            trezorInfo.address,
            '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6' // Third owner
        ];

        const multiSigContractAddress = '0x1234567890123456789012345678901234567890'; // Example address
        const multiSig = new MultiSigWallet(provider, multiSigContractAddress, owners, 2);

        // Create proposal
        const proposal = await multiSig.proposeTransaction(
            '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
            ethers.utils.parseEther('0.1'),
            '0x',
            'ledger'
        );

        console.log(`Multi-sig proposal created: ${proposal.id}`);
        console.log(`Signatures: ${proposal.signatures.length}/${multiSig.requiredSignatures}`);

        // Add second signature
        const signedProposal = await multiSig.signProposal(proposal, 'trezor');
        console.log(`Second signature added. Total: ${signedProposal.signatures.length}`);

        if (signedProposal.signatures.length >= multiSig.requiredSignatures) {
            console.log('Enough signatures collected - ready to execute');
            // const result = await multiSig.executeTransaction(signedProposal);
            // console.log(`Transaction executed: ${result.transactionHash}`);
        }

        // Disconnect wallets
        console.log('\n7. Disconnecting wallets...');
        await walletManager.disconnectWallet('ledger');
        await walletManager.disconnectWallet('trezor');

    } catch (error) {
        console.error('Error in demonstration:', error.message);
    }
}

// Key Management Utilities
class KeyManager {
    constructor() {
        this.encryptionKey = null;
        this.encryptedKeys = new Map();
    }

    // Generate secure random key
    generateSecureKey() {
        const array = new Uint8Array(32);
        crypto.getRandomValues(array);
        return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
    }

    // Encrypt private key
    async encryptPrivateKey(privateKey, password) {
        const encoder = new TextEncoder();
        const data = encoder.encode(privateKey);

        // Derive key from password
        const keyMaterial = await crypto.subtle.importKey(
            'raw',
            encoder.encode(password),
            'PBKDF2',
            false,
            ['deriveBits', 'deriveKey']
        );

        const key = await crypto.subtle.deriveKey(
            {
                name: 'PBKDF2',
                salt: encoder.encode('hardware-wallet-salt'),
                iterations: 100000,
                hash: 'SHA-256'
            },
            keyMaterial,
            { name: 'AES-GCM', length: 256 },
            false,
            ['encrypt', 'decrypt']
        );

        // Encrypt
        const iv = crypto.getRandomValues(new Uint8Array(12));
        const encrypted = await crypto.subtle.encrypt(
            { name: 'AES-GCM', iv: iv },
            key,
            data
        );

        return {
            encrypted: Array.from(new Uint8Array(encrypted)),
            iv: Array.from(iv)
        };
    }

    // Decrypt private key
    async decryptPrivateKey(encryptedData, password) {
        const encoder = new TextEncoder();
        const decoder = new TextDecoder();

        // Derive key from password
        const keyMaterial = await crypto.subtle.importKey(
            'raw',
            encoder.encode(password),
            'PBKDF2',
            false,
            ['deriveBits', 'deriveKey']
        );

        const key = await crypto.subtle.deriveKey(
            {
                name: 'PBKDF2',
                salt: encoder.encode('hardware-wallet-salt'),
                iterations: 100000,
                hash: 'SHA-256'
            },
            keyMaterial,
            { name: 'AES-GCM', length: 256 },
            false,
            ['encrypt', 'decrypt']
        );

        // Decrypt
        const decrypted = await crypto.subtle.decrypt(
            {
                name: 'AES-GCM',
                iv: new Uint8Array(encryptedData.iv)
            },
            key,
            new Uint8Array(encryptedData.encrypted)
        );

        return decoder.decode(decrypted);
    }
}

// Export classes for use in other modules
module.exports = {
    HardwareWalletManager,
    MultiSigWallet,
    KeyManager,
    demonstrateHardwareWalletIntegration
};

// Run demonstration if called directly
if (require.main === module) {
    demonstrateHardwareWalletIntegration();
}

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Batch Audio Library Cleanup and Delivery

Take a pile of mixed audio files to one shippable library — find and judge duplicates, convert the whole batch to a single format with deliberate encoder settings, fix the CBR or VBR bitrate policy, repair tags and filenames in bulk, and correct playback speed without touching pitch.

Hub

Data Size Unit Conversion Without the KB and KiB Confusion

Convert between bits, bytes, and the decimal SI prefixes KB, MB, GB, TB plus the binary IEC prefixes KiB, MiB, GiB, TiB with the system of every number pinned down before you calculate.

Hub

Prepare and Verify Multilingual Web Typography

Check font coverage, compare heading and body pairs with real copy, configure variable axes, and deliver responsive CSS with verified fallback behavior.

Hub

Professional Assembly of an Excel Workbook

Furnish a bare spreadsheet into a workbook people can use without asking you questions — upgrade the legacy file, fill formulas down with the cells locked, name the ranges, gate inputs with validation dropdowns, let conditional formatting flag outliers, freeze the headers, build the index sheet, and set the workbook up to print.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Finance

Ethereum Address Validator

Check if a string is an Ethereum address. Does not validate address checksums.

AI Tools

AI Image Smart Enhance

Intelligently analyze and enhance image quality using AI vision models

Health

CURB-65 vs PSI vs SMART-COP (Pneumonia Severity Comparison)

Compare three pneumonia severity scores side-by-side from one set of inputs to support concordance reading. CURB-65 (0-5: Confusion, Urea, RR, BP, age ≥65) — quick bedside triage; PSI/PORT (Fine 1997, 5 risk classes) — the most accurate mortality stratification, more complex; SMART-COP (0-10, 2 points each for SBP <90 and hypoxia, 1 point each for multilobar CXR, albumin <3.5, RR ≥25, tachycardia ≥125, confusion, pH <7.35) — predicts need for ICU respiratory/vasopressor support. Each score has a different focus: CURB-65 is fast; PSI is more precise; SMART-COP identifies who needs ICU. The tool reports each score's total/category/interpretation and an agreement analysis (whether all three point to outpatient/admission/ICU). When scores disagree, favor the more conservative disposition. Derived from Lim 2003, Fine 1997, Charles 2008. Not medical advice.

Text Processing

Smart Quote Wrapper

Wrap whole text, lines, or sentences with typographic quotes, nested quote pairs, and language-aware punctuation.

Media

Stream Smart Remux

Rewrap media containers with stream copy.

AI Tools

AI Text Summarizer - Smart Content Analysis

Intelligently extract key points from articles and generate high-quality summaries. Support multiple styles and lengths for academic papers, news, reports, and various text types

Media

Video Smart Mux

Combine video with external audio using copy mode.

Development

HTML Tags Reference

Complete reference guide for all standard HTML5 tags with categories and descriptions

Blockchain

Ethers.js Ethereum Library

Ethers.js examples including providers, wallets, contracts, transactions, events, signing, utilities, and blockchain interaction patterns

Blockchain

Hardhat Development Framework Samples

Hardhat Ethereum development environment examples including smart contracts, testing, deployment, scripts, plugins, and development workflows

Blockchain

Truffle Development Suite Samples

Truffle Ethereum development framework examples including smart contracts, testing, deployment, migrations, debugging, and development workflows

Blockchain

Web3.py Python Library

Web3.py Python library examples including blockchain interaction, smart contracts, wallet management, transactions, and decentralized application development

Blockchain

Solana Development with Rust

Comprehensive Solana blockchain development examples including Rust smart contracts with Anchor, high-performance programs, NFT development, and program deployment

Blockchain

Web3 Frontend Integration

Advanced Web3 frontend integration examples including Ethers.js/Web3.js, multi-chain wallet support, DeFi protocol interactions, and NFT marketplace interfaces