Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
JavaScript
Branch: master
Pull request Compare This branch is 3 commits ahead, 120 commits behind ryancbarry:master.

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
.meteor
client
server
templates
.gitignore
Mellifera.css
Mellifera.html
README.md

README.md

Mellifera

A time-trading system.

To do:

  • Find users

Open Economics

  1. An explanation of money and wealth.
  2. Contribution, the start of the Monetary Cycle.
  3. Payment and compensation, the end of the Monetary Cycle.
  4. The case for shared surplus and occupational information.

Time-trading rules

  1. Members may have only one account.
  2. Do not over-report your hours; be honest when accounting for time worked.
  3. Do not waste others' time; share knowledge of best practices.
  4. Do not waste your own time; use best practices whenever possible, and seek guidance when you need it.
  5. Do not hoard money indefinitely; spend it regularly.

Rule 1 ensures that everyone gets the same amount of dividends and liability limit. Rules 2-5 help stabilize the money supply. Failing to abide by these rules causes the community currency to lose its usefulness, and should be grounds for the termination of membership.

How to use Mellifera

  • How to start a time-trading community server
  • How to report a contribution of time
  • How to pay someone

Early prototype:

    /******************************************************
    2011/9/29: Records a contribution event.
        Generates a given amount of credit, backed by debt, in a given member's account.
        Leaves a balance of credit and debt in the system.

        Checks for the liability limit before applying.
        The production-ready version should also check for the rate limit before applying.
    */
    function contribute(memberId, amount)
    {
        var availableDebt = gLiabilityLimit - gDebt[memberId];
        var remaining = availableDebt - amount;

        if (remaining < 0)
        {
            remaining = Math.abs(remaining);
            amount -= remaining;
        }

        gCredit[memberId] += amount;
        gDebt[memberId] += amount;
    }

    /******************************************************
    2011/9/29: Takes credit from the buyer's account, and applies it to the seller's shared debt.
        If there isn't enough credit in the buyer's account, the payment is aborted.
    */
    function payment(buyerMemberId, sellerMemberId, amount)
    {
        var success = false;

        // This makes sure there's enough credit for the payment.
        if (gCredit[buyerMemberId] >= amount)
        {
            // If there's enough buyer's credit to afford the payment, 
            //  we deduct the amount of the payment from their credit.
            gCredit[buyerMemberId] -= amount;

            // Now we deduct the amount of the payment from the seller's debt.
            var excessCredit = applyCreditToDebt(sellerMemberId, amount);
            if (excessCredit != 0)
            {
                gCommunityFund += excessCredit;

                // Now that we have some new shared credit, it should immediately be distributed.
                distributeDividends();
            }

            success = true;
        }

        return success;
    }

    /******************************************************
    2011/10/17: Applies a credit to a member's debt.
        Returns any excess credit.
    */
    function applyCreditToDebt(memberId, amount)
    {
        // First applies the dividend to the member's debt.
        var excessCredit = 0;
        var newDebt = gDebt[memberId] - amount;
        if (newDebt < 0)
        {
            // If there is any part of the dividend remaining, then the debt has been nullified,
            //  and the remainder can be applied to the member's credit.
            gDebt[memberId] = 0;
            excessCredit = Math.abs(newDebt);
        }
        else
        {
            // Here, there's more member's debt than credit in the dividend payment.
            gDebt[memberId] = newDebt;
        }

        return excessCredit;
    }

    /******************************************************
    2011/9/29: Evenly distributes all credit in the Community Fund to each member.
    */
    function distributeDividends()
    {
        var remainder = gCommunityFund % gMemberCount;
        var divisibleFund = gCommunityFund - remainder;

        gCommunityFund = remainder;
        var dividendAmount = divisibleFund / gMemberCount;

        for(var i = 0; i < gMemberCount; i++)
        {
            // Pays dividend for this member.
            var excessCredit = applyCreditToDebt(i, dividendAmount);
            gCredit[i] += excessCredit;
        }
    }

    /******************************************************
    2011/9/29: Throws an error if the money supply is out of balance.
        There should be an equal amount of credit and debt in the system at any given time.
    */
    function checkForValidMoneySupply()
    {
        // Add up the total amount of credit in the system.
        var totalCredit = gCommunityFund;
        var totalDebt = 0;
        for(var i = 0; i < gMemberCount; i++)
        {
            totalCredit += gCredit[i];
            totalDebt += gDebt[i];
        }

        var diff = Math.abs(totalCredit - totalDebt);

        var details = {};
        details.success = false;
        details.totalCredit = totalCredit;
        details.totalDebt = totalDebt;
        details.diff = diff;

        if (diff == 0)
            details.success = true;

        return details;
    }

    function isInteger(amount)
    {
        if (amount === parseInt(amount, 10))
            return true;

        return false;
    }

    function roundCurrency(hours)
    {
        return (Math.round(hours * 100) / 100).toFixed(2);
    }

    function hoursFromCents(amount)
    {
        var hours = amount / 100;

        return roundCurrency(hours);
    }

    function centsFromHours(hours)
    {
        hours = roundCurrency(hours);
        var amount = hours * 100;

        return Math.round(amount);
    }
Something went wrong with that request. Please try again.