• Small Betting Game

Lior Yaffe, core developer and co-founder of Jelurida, announced an add-on had been uploaded to the testnet data cloud; a small betting game contract. You can send some (test!-) ARDR, IGNIS, or other child chain tokens to the account, using a TESTNET account, and the contract will automagically send you between zero and twice the amount you sent.

Lior wrote the following instructions:

We created a small betting game (I call it Ping Pong) for you, based on a “smart contract” deployed as cloud data.

On the Ardor TESTNET send some ARDR, IGNIS or other child chain token amount to account ARDOR-XK4R-7VJU-6EQG-7R335 with a prunable non-encrypted message pointing to the smart contract transaction.

The message text should be exactly {“chain”:2, “fullHash”:”ca2e8a26f9ed2fecf772a40346ec98d156834f85be6b8c31e58046a9f45021f2″}

As a result the contract will send you back between 0 and twice the amount you sent, good luck!

See attached image [the message text is another in the image].

You don’t need to pay gas for this contract and you can program in Java. On the other hand this “contract” is only executed by anyone running the addon and it’s not part of the consensus i.e. you can verify that anyone who created a transaction based on this contract did not cheat, but if they cheat or just choose not to run the contract then you cannot fix it. i.e. some trust in the contract executor is required.

Source code:

package nxt.addons;

import nxt.Nxt;
import nxt.NxtException;
import nxt.account.PaymentAttachment;
import nxt.account.PaymentFxtAttachment;
import nxt.blockchain.Attachment;
import nxt.blockchain.Block;
import nxt.blockchain.Chain;
import nxt.blockchain.ChildChain;
import nxt.blockchain.ChildTransaction;
import nxt.blockchain.Transaction;
import nxt.http.JSONData;
import nxt.util.Convert;
import nxt.util.Logger;
import org.json.simple.JSONObject;

import java.math.BigInteger;
import java.util.Random;

@SuppressWarnings("unused")
public class RandomPaymentContract implements Contract {

    /**
     * Sample contract which receives amount from the trigger transaction and returns a random amount between 0 and twice the received amount
     * @param context contract context
     * @return transaction json
     */
    @Override
    public JSONObject execute(ContractContext context) {
        Logger.logInfoMessage("RandomPaymentContract started");
        JSONObject response = validateInput(context);
        if (response != null) {
            return response;
        }
        Transaction triggerTransaction = context.getTransaction();
        Random r = getRandom(context);
        long amount = triggerTransaction.getAmount();
        long returnAmount = BigInteger.valueOf(Math.abs(r.nextLong())).multiply(BigInteger.valueOf(2)).multiply(BigInteger.valueOf(amount)).divide(BigInteger.valueOf(Long.MAX_VALUE)).longValue();
        Logger.logInfoMessage(String.format("amount paid %d amount returned %d", amount, returnAmount));
        Chain chain = triggerTransaction.getChain();
        String secretPhrase = context.getProperty("secretPhrase");
        byte[] publicKey = Convert.parseHexString(context.getProperty("publicKey"));
        long feeRateNQTPerFXT = Long.parseUnsignedLong(context.getProperty("feeRateNQTPerFXT"));
        long recipient = triggerTransaction.getSenderId();
        return sendMoney(secretPhrase, publicKey, chain, recipient, returnAmount, feeRateNQTPerFXT);
    }

    private JSONObject validateInput(ContractContext context) {
        Transaction triggerTransaction = context.getTransaction();
        if (triggerTransaction.getRecipientId() != Convert.parseAccountId(context.getProperty("rsAccount"))) {
            String message = String.format("trigger account %s differ from contract account %s", Convert.rsAccount(triggerTransaction.getRecipientId()), context.getProperty("rsAccount"));
            Logger.logInfoMessage(message);
            JSONObject response  = new JSONObject();
            response.put("errorCode", 10001);
            response.put("errorDescription", message);
            return response;
        }
        if (triggerTransaction.getSenderId() == Convert.parseAccountId(context.getProperty("rsAccount"))) {
            String message = String.format("trigger account %s is the same as contract account - paying yourself is not supported", Convert.rsAccount(triggerTransaction.getRecipientId()));
            Logger.logInfoMessage(message);
            JSONObject response  = new JSONObject();
            response.put("errorCode", 10002);
            response.put("errorDescription", message);
            return response;
        }
        return null;
    }

    /**
     * Create predictable random seed that all nodes running the contract will generate the same random values
     * @param context contract context
     * @return random number generator
     */
    private Random getRandom(ContractContext context) {
        Block block = context.getBlock();
        byte[] generationSignature = block.getGenerationSignature();
        long seed = Convert.fullHashToId(generationSignature);
        Random r = new Random();
        r.setSeed(seed);
        return r;
    }

    private JSONObject sendMoney(String secretPhrase, byte[] publicKey, Chain chain, long recipient, long amount, long feeRateNQTPerFXT) {
        Attachment attachment = chain instanceof ChildChain ? PaymentAttachment.INSTANCE : PaymentFxtAttachment.INSTANCE;
        Transaction.Builder builder = chain.newTransactionBuilder(publicKey, amount, -1, (short)15, attachment);
        builder.recipientId(recipient).timestamp(Nxt.getBlockchain().getLastBlockTimestamp());
        if (builder instanceof ChildTransaction.Builder) {
            ((ChildTransaction.Builder)builder).feeRateNQTPerFXT(feeRateNQTPerFXT);
        }
        Transaction newTransaction;
        try {
            newTransaction = builder.build(secretPhrase);
        } catch (NxtException.NotValidException e) {
            throw new IllegalStateException(e);
        }
        JSONObject response = new JSONObject();
        response.put("unconfirmedTransaction", JSONData.unconfirmedTransaction(newTransaction));
        Logger.logInfoMessage("RandomPaymentContract transaction created " + response.toJSONString());
        if (secretPhrase != null) {
            try {
                Nxt.getTransactionProcessor().broadcast(newTransaction);
                Logger.logInfoMessage("RandomPaymentContract transaction broadcast");
            } catch (NxtException.ValidationException e) {
                throw new IllegalStateException(e);
            }
        } else {
            Logger.logInfoMessage("RandomPaymentContract transaction not broadcast since secretPhrase not provided to the contract");
        }
        return response;
    }
}

(Back to the Index)

• Weekly Reminder: IGNIS Applications

A while ago community member segfaultsteve wrote a great blog post here on Nxter, brainstorming “interesting applications” that could be built on Ignis. This week’s reminder is in line with that: if YOU have an idea for a great application or want to learn more about Ignis’ inbuilt features and whether they can solve a problem for you or your peers, feel free to join the ArdorNxt Slack and introduce it to the community.

Last week Xavier wanted to know how the Ignis transaction fees compare to the competition when the use case is issuing tickets on the blockchain. Here is a summary of the conversation it sparked:

Xavier [9:31 PM]

I’d be interested in a comparison of actual prices in usd a company issuing tickets on the blockchain would have to pay per 10.000 tickets sold using a token on the Ethereum platform for this versus using the Ardor platform for end users. Ether valued at 1000, 2000 and 3000 usd and Ardor valued at 10, 20, 30 usd. Anyone in here able to calculate this?

martis [9:34 PM]

Child chain fee is 0.01 ARDR. So 0.1, 0.2, 0.3 USD per transaction.

Xavier [9:41 PM]

A company that organises big events regularly might issue thousands of tickets as a daily average. Would it always cost 1 Ardor to bundle 100 child-chain transactions? Would you need 1000 Ardor to bundle 100.000 child chain transactions? At a value of 10 dollar per ardor it would cost 10.000 usd to issue 100.000 tickets?

martis [9:57 PM]

Your math is correct, but not for issuing the tickets. For making 100.000 transactions.

Xavier [9:58 PM]

Thanks Martis. So at a valuation of 10 usd per Ardor, the ticket issuer would pay 10 cents per transaction. At a valuation of 20 usd per Ardor 20 cents etc. I guess that’s a pretty good deal. I can’t do the math on the Ethereum equivalent. Don’t know enough about it yet.

martis [10:01 PM]

I think if ARDR is 10 USD, then fees could be adjusted by the devs.

Xavier [10:01 PM]

I was wondering about that as well. Fees for forging should be able to be lowered when Ardor valuation goes up to prevent transactions becoming too expensive. But lowering forging fees might be a difficult topic.

CullensAnton [10:02 PM]

@Xavier That already happened. Fees have been lowered once already.

martis

My idea was wider, not just concert tickets, but also internal festival money, instead of fiat.

CullensAnton 

Yes, the wider, the better
Museum, Swimming pools, Fancy fairs etc etc

Xavier 

@martis: I was already thinking about replacing event food/drinks coins/coupons with tokens as well.

martis

and you can control merchants income inside the festival and ask them to pay not for place, but some % of their income during the festival. If the festival is in the EU, you can use AEUR for internal payments and issue assets, as festival tickets.

Xavier [10:12 PM]

The end user shouldn’t even have to know that a blockchain is somehow involved in the service he is enjoying. 

(Back to the Index)