Scroll to top

DeFi SIP - Coming Soon

Decentralized SIP (DeSIP) – A Decentralized SIP (Systematic Investment Plan), or DeSIP, is a blockchain-based approach to long-term investing, combining the discipline of traditional SIPs with the transparency, security, and automation of decentralized finance (DeFi). Unlike conventional SIPs managed by banks or mutual funds, DeSIPs run on smart contracts, allowing investors to contribute, track, and grow their funds without intermediaries.

Key Features & Benefits

Automated Recurring Investments

Investors can schedule fixed periodic contributions (daily, weekly, monthly) in crypto or stablecoins.
Smart contracts handle automatic transfers and allocations, ensuring discipline without manual intervention.

Transparent & Immutable

All contributions, fund allocation, and growth are recorded on the blockchain.
No hidden charges, no opaque fund management; investors can verify everything in real-time.

High Security & Self-Custody

Funds are held in smart contracts or user-controlled wallets.
End-to-end encryption and blockchain immutability protect investments from fraud, hacks, or misuse.

DeFi Integration & Yield Generation

Funds can be deployed into DeFi protocols such as lending, staking, or liquidity pools to generate variable returns.
Investors earn interest, rewards, or governance tokens while their principal grows.

Flexibility & Global Access

Start with any amount; contributions can be adjusted anytime.
Accessible worldwide without KYC or traditional banking restrictions.

Risk Management & Diversification

Smart contracts can split investments across multiple protocols, assets, or stablecoins to reduce risk.
Optionally, insurance coverage can protect against protocol failure or hacks.

Use Cases

Long-term crypto wealth accumulation
Long-term crypto wealth accumulation
Automated investment plans for DeFi portfolios

Why DeSIP Matters

DeSIP merges the discipline of systematic investing with the openness and efficiency of DeFi, making it ideal for users seeking long-term, transparent, and secure investment growth. It empowers investors to control their financial future, access high-yield opportunities, and track every contribution in a trustless, global, and automated ecosystem.

DeFi SIP Protocol

DeFi SIP

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

/*
---------------------------------------------------------
 DeSIP – Decentralized SIP Prototype
---------------------------------------------------------
 - Users create recurring investment plans
 - Fixed amount + interval
 - Funds routed to DeFi strategies
 - Tracks deposits & yield
---------------------------------------------------------
*/

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    function balanceOf(address user) external view returns (uint256);
}

/*
---------------------------------------------------------
 Strategy Adapter Interface
 Each DeFi protocol should implement this.
---------------------------------------------------------
*/
interface IStrategyAdapter {
    function deposit(uint256 amount) external;
    function withdraw(uint256 amount) external;
    function totalValue() external view returns (uint256);
}

/*
---------------------------------------------------------
 Main DeSIP Contract
---------------------------------------------------------
*/
contract DeSIP {

    enum Interval {
        DAILY,
        WEEKLY,
        MONTHLY
    }

    struct SIPPlan {
        address investor;
        IERC20 token;

        uint256 amountPerCycle;
        uint256 startTime;
        uint256 lastDepositTime;
        uint256 totalInvested;

        Interval interval;
        bool active;

        address[] strategies;
        uint256[] allocations; // % in basis points (10000 = 100%)
    }

    uint256 public planCounter;

    mapping(uint256 => SIPPlan) public plans;
    mapping(address => uint256[]) public userPlans;

    event SIPCreated(uint256 indexed planId, address indexed user);
    event SIPExecuted(uint256 indexed planId, uint256 amount);
    event SIPPaused(uint256 indexed planId);
    event SIPResumed(uint256 indexed planId);
    event SIPCancelled(uint256 indexed planId);
    event Withdrawn(uint256 indexed planId, uint256 amount);

    uint256 private constant BPS = 10_000;

    /* -------------------------------------------------- */

    function createSIP(
        IERC20 token,
        uint256 amountPerCycle,
        Interval interval,
        address[] calldata strategies,
        uint256[] calldata allocations
    ) external returns (uint256) {
        require(amountPerCycle > 0, "Zero amount");
        require(strategies.length == allocations.length, "Mismatch");

        uint256 totalAlloc;
        for (uint256 i; i < allocations.length; i++) {
            totalAlloc += allocations[i];
        }
        require(totalAlloc == BPS, "Alloc must be 100%");

        planCounter++;

        SIPPlan storage p = plans[planCounter];
        p.investor = msg.sender;
        p.token = token;
        p.amountPerCycle = amountPerCycle;
        p.interval = interval;
        p.startTime = block.timestamp;
        p.lastDepositTime = 0;
        p.active = true;
        p.strategies = strategies;
        p.allocations = allocations;

        userPlans[msg.sender].push(planCounter);

        emit SIPCreated(planCounter, msg.sender);

        return planCounter;
    }

    /* -------------------------------------------------- */

    function _intervalSeconds(Interval i) internal pure returns (uint256) {
        if (i == Interval.DAILY) return 1 days;
        if (i == Interval.WEEKLY) return 7 days;
        return 30 days;
    }

    function canExecute(uint256 planId) public view returns (bool) {
        SIPPlan storage p = plans[planId];
        if (!p.active) return false;

        uint256 last = p.lastDepositTime == 0
            ? p.startTime
            : p.lastDepositTime;

        return block.timestamp >= last + _intervalSeconds(p.interval);
    }

    /* -------------------------------------------------- */
    // Anyone can trigger execution (keeper / bot friendly)
    function executeSIP(uint256 planId) external {
        require(canExecute(planId), "Not due");

        SIPPlan storage p = plans[planId];

        uint256 amount = p.amountPerCycle;

        require(
            p.token.transferFrom(p.investor, address(this), amount),
            "Transfer failed"
        );

        // Allocate into strategies
        for (uint256 i; i < p.strategies.length; i++) {
            uint256 portion = (amount * p.allocations[i]) / BPS;

            p.token.transfer(p.strategies[i], portion);
            IStrategyAdapter(p.strategies[i]).deposit(portion);
        }

        p.lastDepositTime = block.timestamp;
        p.totalInvested += amount;

        emit SIPExecuted(planId, amount);
    }

    /* -------------------------------------------------- */

    function pauseSIP(uint256 planId) external {
        SIPPlan storage p = plans[planId];
        require(msg.sender == p.investor, "Not owner");

        p.active = false;
        emit SIPPaused(planId);
    }

    function resumeSIP(uint256 planId) external {
        SIPPlan storage p = plans[planId];
        require(msg.sender == p.investor, "Not owner");

        p.active = true;
        emit SIPResumed(planId);
    }

    /* -------------------------------------------------- */

    function cancelSIP(uint256 planId) external {
        SIPPlan storage p = plans[planId];
        require(msg.sender == p.investor, "Not owner");

        p.active = false;

        emit SIPCancelled(planId);
    }

    /* -------------------------------------------------- */
    // Withdraw everything from strategies
    function withdrawAll(uint256 planId) external {
        SIPPlan storage p = plans[planId];
        require(msg.sender == p.investor, "Not owner");

        uint256 beforeBal = p.token.balanceOf(address(this));

        for (uint256 i; i < p.strategies.length; i++) {
            IStrategyAdapter strat = IStrategyAdapter(p.strategies[i]);

            uint256 val = strat.totalValue();
            strat.withdraw(val);
        }

        uint256 afterBal = p.token.balanceOf(address(this));
        uint256 gained = afterBal - beforeBal;

        p.token.transfer(p.investor, gained);

        emit Withdrawn(planId, gained);
    }
}