Solidity Real-Time Data – Updating Matic Price Inside a Smart Contract

go-ethereumsolidity

I'm working on a smart contract that allows users to pay for monthly subscriptions like Netflix, Amazon, etc…

Assuming that each subscription costs 20$ per month which is equivalent to 22 Matic at the time of writing this post.

During the time of the subscription, the user should pay 20$ per month with Matic, and its value will vary.

How can I update the monthly payment inside the smart contract so the subscriber will be able to pay each with the current value of MATIC not more not less? It's possible in solidity?

Or should I let the user pay his subscription manually each month based on the price of each subscription in dollars but with MATIC?

I tried to implement a solution with Tellor in my smart contract but I got stuck.

// smart contract subscription(part of it)
struct Subscription {
        address payable subscriber;
        uint start;
        uint nextPayment;
        bool activated;
    }

    
    /* nested mapping from address to id to Subscription */ 
    mapping(address => mapping(uint => Subscription)) private AllSubscriptions;


 function pay(address subscriber, uint planId) external {
    Subscription storage subscription = subscriptions[subscriber][planId];
    Plan storage plan = plans[planId];
    IERC20 token = IERC20(plan.token);
    require(
      subscription.subscriber != address(0), 
      'this subscription does not exist'
    );
    require(
      block.timestamp > subscription.nextPayment,
      'not due yet'
    );

    token.transferFrom(subscriber, plan.merchant, plan.amount);  
    emit PaymentSent(
      subscriber,
      plan.merchant, 
      plan.amount, 
      planId, 
      block.timestamp
    );
    subscription.nextPayment = subscription.nextPayment + plan.frequency;
  }

// UsingTellor functionnalities
// SPDX-License-Identifier: GPL-3.0
  pragma solidity ^0.8.0;

  import "usingtellor/contracts/UsingTellor.sol";

  contract PriceContract is UsingTellor {

  uint256 public btcPrice;

  //This Contract now has access to all functions in UsingTellor

  constructor(address payable _tellorAddress) UsingTellor(_tellorAddress) public {}

  function setBtcPrice() public {

    bytes memory _b = abi.encode("SpotPrice",abi.encode("MATIC","USD"));
    bytes32 _queryID = keccak256(_b);

    bool _didGet;
    uint256 _timestamp;
    bytes _value;

    (_didGet, _value, _timestamp) = getDataBefore(_queryID);

    uint256 maticPrice = abi.decode(_value,(uint256));

    require(token.transferFrom(subscriber,address(this),cost/maticPrice));
  }
}

Best Answer

following up on @thefett's code here's one way to do it in your project.

    // UsingTellor functionnalities
// SPDX-License-Identifier: GPL-3.0
  pragma solidity ^0.8.0;

  import "usingtellor/contracts/UsingTellor.sol";

  contract PriceContract is UsingTellor {

  uint256 public maticPrice;
  uint256 public cost = 20 ether;

  uint256 public monthlyPayment;

  //This Contract now has access to all functions in UsingTellor
  constructor(address payable _tellorAddress) UsingTellor(_tellorAddress) public {}

// smart contract subscription(part of it)
struct Subscription {
        address payable subscriber;
        uint start;
        uint nextPayment;
        bool activated;
    }

    
    /* nested mapping from address to id to Subscription */ 
    mapping(address => mapping(uint => Subscription)) private AllSubscriptions;

/* Pay subcription every Month*/
    function pay(uint256 planId) 
        external payable
        onlyUsers()
        {
        Subscription storage submitSubscription = AllSubscriptions[msg.sender][planId];

        require(block.timestamp > submitSubscription.nextPayment, " Payment not due yet");
        Plan storage plan = idToPlan[planId];

        // require(msg.value >= plan.monthlyPayment, " Monthly payment not correct");
        require(msg.value >= monthlyPayment, "Monthly payment not correct");

        emit PaymentSent(
            payable(msg.sender),
            payable(address(this)),
            plan.monthlyPayment,
            planId,
            block.timestamp);
        totalPaymentsPerWallet[msg.sender] += 1; 
        submitSubscription.nextPayment = submitSubscription.nextPayment + 4 weeks;

    }


 function setMaticPrice() public {

    bytes memory _b = abi.encode("SpotPrice",abi.encode("matic","usd"));
    bytes32 _queryID = keccak256(_b);

    bool _didGet;
    uint256 _timestamp;
    bytes memory _value;

    (_didGet, _value, _timestamp) = getDataBefore(_queryID, block.timestamp - 5 minutes);

    maticPrice = abi.decode(_value,(uint256));

    uint256 price = (cost/maticPrice);

    monthlyPayment = price * 10 **18;

  }


}

Related Solutions

Solidity – Handling Unimplemented Functions in Contracts

The problem is that totalSupply() implementation is missing. Seems like autogenerated getters do not count. So you need to explicitly create the function.

contract StandardToken is Token {
    uint256 _totalSupply;

    function totalSupply() constant returns (uint256 totalSupply) {
        totalSupply = _totalSupply;
    }
}

Solidity – How to Return All the Structs Inside a Nested Mapping

To help you, I wrote a contract with functions that can return list of all addresses subscribed to a specific subscription plan (0,1,2 ....) + other functions like deleteUser(),subscribeUser() etc.

It's example of how you can do it all without for loops (you instead use mapping to remember "index")

This is a simple example where every user only has a single subscription, but it can be modified such that a single user has as many subscriptions as you wish. But I tried to keep it simple/redable so as to not overwhelm you.

Hope it helps.

// SPDX-License-Identifier: MIT
    pragma solidity ^0.8.10;
    
    contract SubscriptionContract {
    
     mapping(uint => Subscription) public subscriptionMap;
     mapping(address => UserData) public userMap; //Helps to know which user is subscribed to which service
    
    
    struct Subscription {
        string subscriptionName; //Netflix,Amazon etc
        address[] addresses;
    }
    
    struct UserData {
        uint subscriptionID; //Code number for Netflix,Amazon etc
        uint index; //Users location is array of addresses (So we can delete it without For loop)
    }
    
    function createSubscription(uint subscriptionID, string calldata name) public {
        subscriptionMap[subscriptionID].subscriptionName = name; //Netflic,Amazon etc
    
    }
    
    //User subscribes himself 
    function subscribeUser(uint subscriptionID) public {
    
        userMap[msg.sender].index = subscriptionMap[subscriptionID].addresses.length;
    
        subscriptionMap[subscriptionID].addresses.push(msg.sender);
        userMap[msg.sender].subscriptionID=subscriptionID;
        
    
    }
    
    
    //We delete specific user from subscription
    function deleteUser(address userAddress) public {
    
        //First we find his subscriptionID
        uint subscriptionID = userMap[userAddress].subscriptionID;
    
        //Next we find user's location in the array
        uint index = userMap[userAddress].index;
    
        //Now we delete the user from subscription (if it's there)
    
        //Deleting a member in array is done by replacing it with the last member of the array
        uint lastIndex= subscriptionMap[subscriptionID].addresses.length -1;
        subscriptionMap[subscriptionID].addresses[index] = subscriptionMap[subscriptionID].addresses[lastIndex]; //Replacment
        subscriptionMap[subscriptionID].addresses.pop(); //Removing value at lastIndex
    
    }
    
    
    function getAllSubscribers(uint subscriptionID) public view returns (address[] memory) {
    
        return subscriptionMap[subscriptionID].addresses;
    
    }
    
    }

EDIT: Considering you said the first answer did not suit your needs, I just tried to fix your code (What is a bit tricky as we don't have entire contract so I have to guess some stuff)

I think your issue was mixing unit currentIndex vs unit currentId, you seem to be using both instead only one of those variables.

Below is adapted version of your code.

// SPDX-License-Identifier: MIT
    pragma solidity ^0.8.10;
    
    contract AllSubscriptions {



struct Subscription {
    address subscriber;
    uint start;
    uint nextPayment;
  }


mapping(address => mapping(uint => Subscription)) public subscriptions;

uint totalSubscriptions; //Number of subscriptions

function addSubscription(uint subscriptionID, uint startDate) public {

    subscriptions[msg.sender][subscriptionID].start = startDate; //Added new subscription
    subscriptions[msg.sender][subscriptionID].subscriber = msg.sender; //Added new subscription
    totalSubscriptions +=1;
    }

function getAllsubscriptions() public view returns (Subscription[] memory) {

        Subscription[] memory items = new Subscription[](totalSubscriptions);

        //We asume subscriptionID's are incremental (from 0 -> totalSubscriptions)
        for(uint i = 0; i < totalSubscriptions; i++) {
            uint subscriptionID = i;
            // pointer 
            Subscription storage currentSubscription = subscriptions[msg.sender][subscriptionID];
            items[subscriptionID] = currentSubscription;
            subscriptionID += 1;
        }

        return items;
    }

    }

EDIT2: Second version of contract (Here for simplicity I assumed every user only has a single Subscription + subscriptionID cant be Zero)

// SPDX-License-Identifier: MIT
    pragma solidity ^0.8.10;
    
contract AllSubs {



struct Subscription {
    address subscriber;
    uint start;
    uint nextPayment;
  }


mapping(address => mapping(uint => Subscription)) public subscriptions;  //uint = 0 is a default value, so no subscription should have that number as its ID. 

uint totalSubscriptions; //Number of subscriptions

address[] allSubcribers; //Array contaning all subscribers
uint[] subscriptionList; //This way I know who has what subscriptionID

function addSubscription(uint subscriptionID, uint startDate) public {

    if (subscriptions[msg.sender][0].start == 0){
        allSubcribers.push(msg.sender); //Adding address to the list if this is its first subscription
        subscriptionList.push(subscriptionID);
    }

    subscriptions[msg.sender][subscriptionID].start = startDate; //Added new subscription startDate
    subscriptions[msg.sender][subscriptionID].subscriber = msg.sender; //Added new subscription
    totalSubscriptions +=1;

   

    }


function getAllsubscriptions() public view returns (Subscription[] memory) {

        Subscription[] memory items = new Subscription[](totalSubscriptions);

        //We asume subscriptionID's are incremental (from 0 -> totalSubscriptions)
        for(uint i = 0; i < allSubcribers.length; i++) {
            address subscriberAddress = allSubcribers[i];
            uint subscriptionID = subscriptionList[i];
            // pointer 
            Subscription storage currentSubscription = subscriptions[subscriberAddress][subscriptionID];
            items[i] = currentSubscription;
        }

        return items;
    }


    }

Best Answer

Related Solutions

Solidity – Handling Unimplemented Functions in Contracts

Solidity – How to Return All the Structs Inside a Nested Mapping

Related Topic