Airdrop Contract

contracts/Airdrop.sol

@@ -0,0 +1,177 @@
+/* solhint-disable-next-line compiler-fixed */
+pragma solidity ^0.4.17;
+
+// Copyright 2018 OpenST Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// ----------------------------------------------------------------------------
+// Utility chain: Airdrop
+//
+// http://www.simpletoken.org/
+//
+// ----------------------------------------------------------------------------
+
+import "./Workers.sol";
+import "./Pricer.sol";
+
+
+contract Airdrop is Pricer, Workers {
+
+    /*
+     *  Events
+    */
+    /// Event for AirdropPayment complete
+    event AirdropPayment(
+        address _beneficiary,
+        uint256 tokenAmount,
+        address _commissionBeneficiary,
+        uint256 commissionTokenAmount,
+        uint256 _actualPricePoint,
+        address _spender,
+        uint256 _airdropAmount
+        );
+
+    /*
+     *  Storage
+     */
+    Workers public workers;
+    address public airdropBudgetHolder;
+
+    /*
+      *  Constructor
+     */
+    /// @dev    Takes _brandedToken, _baseCurrency, _workers, _airdropBudgetHolder;
+    ///         constructor;
+    ///         public method;
+    /// @param _brandedToken Branded Token
+    /// @param _baseCurrency Base Currency
+    /// @param _workers  Workers contract address
+    /// @param _airdropBudgetHolder Airdrop Budget Holder Address
+    function Airdrop(
+        address _brandedToken,
+        bytes3 _baseCurrency,
+        Workers _workers,
+        address _airdropBudgetHolder)
+        public
+        Pricer(_brandedToken, _baseCurrency)
+        OpsManaged()
+    {
+        require(_workers != address(0));
+        require(airdropBudgetHolder != address(0));
+
+        workers = _workers;
+        airdropBudgetHolder = _airdropBudgetHolder;
+    }
+
+    /*
+      *  External functions
+     */
+    /// clean up or revoke airdrop contract
+    function remove()
+        external
+        onlyAdminOrOps
+    {
+        selfdestruct(msg.sender);
+    }
+
+    /*
+     *  External functions
+     */
+    /// performPay matches the behaviour of Pricer:pay with extra functionality of airdrop evaluation
+    /// @param _beneficiary beneficiary
+    /// @param _transferAmount transferAmount
+    /// @param _commissionBeneficiary commissionBeneficiary
+    /// @param _commissionAmount commissionAmount
+    /// @param _currency currency
+    /// @param _intendedPricePoint intendedPricePoint
+    /// @param _spender spender
+    /// @param _airdropAmount airdropAmount
+    /// @return uint256 totalPaid
+    function performPay(
+        address _beneficiary,
+        uint256 _transferAmount,
+        address _commissionBeneficiary,
+        uint256 _commissionAmount,
+        bytes3 _currency,
+        uint256 _intendedPricePoint,
+        address _spender,
+        uint256 _airdropAmount)
+        public
+        returns (
+            uint256 /* totalPaid */)
+    {
+        require(workers.isWorker(msg.sender));
+        require(_spender != address(0));
+
+        require(isValidBeneficiaryData(_beneficiary, _transferAmount, _commissionBeneficiary, _commissionAmount));
+
+        uint256 tokenAmount = _transferAmount;
+        uint256 commissionTokenAmount = _commissionAmount;
+        uint256 pricePoint = _intendedPricePoint;
+
+        // check Margin And Calculate BTAmount
+        if (_currency != "") {
+            (pricePoint, tokenAmount, commissionTokenAmount) = validateMarginAndCalculateBTAmount(_currency,
+                _intendedPricePoint, _transferAmount, _commissionAmount);
+        }
+
+        require(performAirdropTransferToSpender(_spender, _airdropAmount,
+            tokenAmount, commissionTokenAmount));
+        require(performTransfer(_spender, _beneficiary, tokenAmount,
+            _commissionBeneficiary, commissionTokenAmount));
+
+        /// Emit AirdropPayment Event
+        AirdropPayment(_beneficiary, tokenAmount, _commissionBeneficiary,
+            commissionTokenAmount, pricePoint, _spender, _airdropAmount);
+
+        return ((tokenAmount + commissionTokenAmount));
+    }
+
+    /*
+     *  Private functions
+     */
+    /// @dev    Takes _spender, _airdropAmount, _tokenAmount, _commissionTokenAmount;
+    ///         Calculate airdropUsed to transfer
+    ///         Perform perform Airdrop Transfer To Spender
+    ///         internal method;
+    /// @param _spender spenderUser
+    /// @param _airdropAmount airdropAmount
+    /// @param _tokenAmount tokenAmount
+    /// @param _commissionTokenAmount commissionTokenAmount
+    /// @return uint256 airdropUsed
+    function performAirdropTransferToSpender(
+        address _spender,
+        uint256 _airdropAmount,
+        uint256 _tokenAmount,
+        uint256 _commissionTokenAmount)
+        private
+        returns (
+            bool /* boolean value */)
+    {
+        // @Ben Do we need this? Can't we transfer all _airdropAmount to _spender?
+        uint256 airdropUsed = _airdropAmount;
+        uint256 totalPaid = (_tokenAmount + _commissionTokenAmount);
+        if (_airdropAmount > totalPaid) {
+            airdropUsed = _airdropAmount - totalPaid;
+        }
+
+        // Prefund the user from the airdrop budget holder
+        if (airdropUsed > 0) {
+            require(EIP20Interface(brandedToken()).transferFrom(airdropBudgetHolder, _spender, airdropUsed));
+        }
+
+        return true;
+    }
+
+}

contracts/Pricer.sol

@@ -1,3 +1,4 @@
+/* solhint-disable-next-line compiler-fixed */
 pragma solidity ^0.4.17;
 
 // Copyright 2018 OpenST Ltd.
@@ -60,8 +61,8 @@ contract Pricer is OpsManaged, PricerInterface {
     /// @dev    Takes _brandedToken, _baseCurrency; 
     ///         constructor;
     ///         public method;
-    /// @param _brandedToken _brandedToken
-    /// @param _baseCurrency _baseCurrency    
+    /// @param _brandedToken Branded Token
+    /// @param _baseCurrency Base Currency
     function Pricer(
         address _brandedToken,
         bytes3 _baseCurrency)
@@ -251,7 +252,7 @@ contract Pricer is OpsManaged, PricerInterface {
     /// @param _commissionAmount commissionAmount
     /// @param _currency currency
     /// @param _intendedPricePoint _intendedPricePoint
-    /// @return bool isSuccess
+    /// @return uint256 total paid
     function pay(       
         address _beneficiary,
         uint256 _transferAmount,        
@@ -260,36 +261,28 @@ contract Pricer is OpsManaged, PricerInterface {
         bytes3 _currency,
         uint256 _intendedPricePoint)
         public
-        returns (bool /* success */)
+        returns (uint256 /* total paid */)
     {
-        require(_beneficiary != address(0));
-        require(_transferAmount != 0);
-
-        if (_commissionAmount > 0) {
-            require(_commissionBeneficiary != address(0));
-        }
+        require(isValidBeneficiaryData(_beneficiary, _transferAmount,
+            _commissionBeneficiary, _commissionAmount));
 
         uint256 tokenAmount = _transferAmount;
         uint256 commissionTokenAmount = _commissionAmount;
         uint256 pricePoint = _intendedPricePoint;
-        if (_currency != 0) {
-            pricePoint = getPricePoint(_currency);
-            require(pricePoint > 0);
-            require(isPricePointInRange(_intendedPricePoint, pricePoint, pricerAcceptedMargins[_currency]));            
-            (tokenAmount, commissionTokenAmount) = getBTAmountFromCurrencyValue(pricePoint, 
-                _transferAmount, _commissionAmount);
-        }
-
-        require(EIP20Interface(pricerBrandedToken).transferFrom(msg.sender, _beneficiary, tokenAmount));
-        if (_commissionBeneficiary != address(0)) {
-            require(EIP20Interface(pricerBrandedToken).transferFrom(msg.sender, 
-                _commissionBeneficiary, commissionTokenAmount));
+
+        // check Margin And Calculate BTAmount
+        if (_currency != "") {
+            (pricePoint, tokenAmount, commissionTokenAmount) = validateMarginAndCalculateBTAmount(_currency,
+                _intendedPricePoint, _transferAmount, _commissionAmount);
         }
-
+
+        require(performTransfer(msg.sender, _beneficiary, tokenAmount,
+            _commissionBeneficiary, commissionTokenAmount));
+
         //Trigger Event for PaymentComplete
         Payment(_beneficiary, _transferAmount, _commissionBeneficiary, 
-            _commissionAmount, _currency, _intendedPricePoint, pricePoint);      
-        return true;
+            _commissionAmount, _currency, _intendedPricePoint, pricePoint);
+        return (tokenAmount + commissionTokenAmount);
     }
 
     /// @dev    Takes _currency; 
@@ -309,7 +302,7 @@ contract Pricer is OpsManaged, PricerInterface {
 
     /// @dev    Takes _intendedPricePoint, _currentPricePoint, _acceptedMargin;
     ///         checks if the current price point is in the acceptable range of intendedPricePoint; 
-    ///         private method;
+    ///         internal method;
     /// @param _intendedPricePoint intendedPricePoint
     /// @param _currentPricePoint currentPricePoint
     /// @param _acceptedMargin acceptedMargin   
@@ -318,7 +311,7 @@ contract Pricer is OpsManaged, PricerInterface {
         uint256 _intendedPricePoint,
         uint256 _currentPricePoint,
         uint256 _acceptedMargin)
-        private
+        internal
         pure
         returns (bool /*isValid*/)
     {
@@ -334,7 +327,7 @@ contract Pricer is OpsManaged, PricerInterface {
 
     /// @dev    Takes _pricePoint, _transferAmount, _commissionAmount; 
     ///         calculates the number of branded token equivalant to the currency amount; 
-    ///         private method;
+    ///         internal method;
     /// @param _pricePoint pricePoint
     /// @param _transferAmount transferAmount
     /// @param _commissionAmount commissionAmount
@@ -343,7 +336,7 @@ contract Pricer is OpsManaged, PricerInterface {
         uint256 _pricePoint,
         uint256 _transferAmount,
         uint256 _commissionAmount)
-        private
+        internal
         view
         returns (uint256, uint256) /* number of BT ,number of commission BT */
     {
@@ -352,4 +345,88 @@ contract Pricer is OpsManaged, PricerInterface {
         uint256 commissionAmountBT = SafeMath.div(SafeMath.mul(_commissionAmount, adjConversionRate), _pricePoint);
         return (amountBT, commissionAmountBT);
     }
+
+    /// @dev    Takes _beneficiary, _transferAmount, _commissionBeneficiary, _commissionAmount;
+    ///         checks if the current price point is in the acceptable range of intendedPricePoint;
+    ///         internal method;
+    /// @param _beneficiary beneficiary
+    /// @param _transferAmount transferAmount
+    /// @param _commissionBeneficiary commissionBeneficiary
+    /// @param _commissionAmount commissionAmount
+    /// @return bool isValid
+    function isValidBeneficiaryData(
+        address _beneficiary,
+        uint256 _transferAmount,
+        address _commissionBeneficiary,
+        uint256 _commissionAmount)
+        internal
+        returns (bool /*isValid*/)
+    {
+        require(_beneficiary != address(0));
+        require(_transferAmount != 0);
+
+        if (_commissionAmount > 0) {
+            require(_commissionBeneficiary != address(0));
+        }
+        return true;
+    }
+
+    /// @dev    Takes _spender, _beneficiary, _tokenAmount, _commissionBeneficiary, _commissionTokenAmount;
+    ///         Perform tokenAmount transfer
+    ///         Perform commissionTokenAmount transfer
+    ///         internal method;
+    /// @param _spender spender
+    /// @param _beneficiary beneficiary
+    /// @param _tokenAmount tokenAmount
+    /// @param _commissionBeneficiary commissionBeneficiary
+    /// @param _commissionTokenAmount commissionTokenAmount
+    /// @return (bool)
+    function performTransfer(
+        address _spender,
+        address _beneficiary,
+        uint256 _tokenAmount,
+        address _commissionBeneficiary,
+        uint256 _commissionTokenAmount)
+        internal
+        returns (
+            bool /* boolean value */)
+    {
+        require(EIP20Interface(pricerBrandedToken).transferFrom(_spender, _beneficiary, _tokenAmount));
+
+        if (_commissionBeneficiary != address(0)) {
+            require(EIP20Interface(pricerBrandedToken).transferFrom(_spender,
+            _commissionBeneficiary, _commissionTokenAmount));
+        }
+        return true;
+    }
+
+    /// @dev    Takes _currency, _intendedPricePoint, _transferAmount, _commissionAmount;
+    ///         Validate accepted margin
+    ///         Calculates tokenAmount and commissionTokenAmount
+    ///         internal method
+    /// @param _currency currency
+    /// @param _intendedPricePoint intendedPricePoint
+    /// @param _transferAmount transferAmount
+    /// @param _commissionAmount commissionAmount
+    /// @return (pricePoint, tokenAmount, commissionTokenAmount)
+    function validateMarginAndCalculateBTAmount(
+        bytes3 _currency,
+        uint256 _intendedPricePoint,
+        uint256 _transferAmount,
+        uint256 _commissionAmount)
+        internal
+        returns (uint256, uint256, uint256) /* pricePoint, tokenAmount, commissionTokenAmount */
+    {
+        uint256 pricePoint = getPricePoint(_currency);
+        require(pricePoint > 0);
+        require(isPricePointInRange(_intendedPricePoint, pricePoint, acceptedMargins(_currency)));
+
+        uint256 tokenAmount;
+        uint256 commissionTokenAmount;
+        (tokenAmount, commissionTokenAmount) = getBTAmountFromCurrencyValue(pricePoint, _transferAmount,
+            _commissionAmount);
+
+        return (pricePoint, tokenAmount, commissionTokenAmount);
+    }
+
 }