• Pequeña Aplicación para Apuestas

Lior Yaffe, desarrollador principal y cofundador de Jelurida, anunció que ha subido un complemento a la nube de datos de la testnet. Se trata de un pequeño contrato inteligente de un juego de apuestas. Puedes enviar algunos (¡pruebalo!-) ARDR, IGNIS u otros tokens de child chain a la cuenta, usando una cuenta de TESTNET, y el contrato automáticamente te devolverá “cero” o el doble de la cantidad que enviaste.

Lior escribió las siguientes instrucciones:

Hemos creado un pequeño juego de apuestas para ti (yo lo llamo ping-pong), basado en un “contrato inteligente” implementado en la nube de datos.

En la TESTNET de Ardor envía cualquier cantidad de ARDR, IGNIS u otros tokens de child chain a la cuenta ARDOR-XK4R-7VJU-6EQG-7R335 a través de un mensaje podable y no encriptado, indicando la transacción del contrato inteligente.

El texto del mensaje debe ser exactamente {“chain”:2, “fullHash”:”ca2e8a26f9ed2fecf772a40346ec98d156834f85be6b8c31e58046a9f45021f2″}

Como resultado, el contrato te enviará de vuelta entre 0 y el doble de la cantidad que enviaste, ¡buena suerte!

Ver imagen adjunta [el texto del mensaje es otro en la imagen].

No necesitas pagar con gas para este contrato y lo puedes programar en Java. Por otro lado, este “contrato” únicamente lo pueden ejecutar las personas que ejecuten el complemento y no forma parte del consenso, es decir, puedes verificar que cualquier que haya creado una transacción basada en este contrato no hizo trampa, pero si hubiesen hecho trampa o simplemente hubiesen escogido no ejecutarlo, entonces no puedes corregirlo. Es decir, se requiere cierta confianza en el ejecutor del contrato.

Código fuente:

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;
    }
}

(Volver al Índice)

• Recordatorio Semanal: Aplicaciones de IGNIS

Hace ya un tiempo que un miembro de la comunidad, segfaultsteve, escribió una gran entrada de blog aquí en Nxter, aportando ideas sobre “interesantes aplicaciones” que podrían construirse en Ignis. El recordatorio de esta semana está en consonancia con eso: si TÚ tienes una idea sobre una buena aplicación o deseas obtener más información acerca de las características integradas en Ignis y si pueden ayudarte resolver un problema para ti o tus compañeros, siéntete libre de unirte al slack de Ardor y Nxt y preséntasela a la comunidad.

La semana pasada Xavier quería saber cómo comparar las tasas de transacción de Ignis con la competencia cuando el caso de uso es la emisión de tikets en la blockchain. Aquí hay un resumen de la conversación que siguió a esta pregunta:

Xavier [9:31 PM]

Estaría interesado en una comparativa de los precios reales en dólares que una empresa emisora de tiquets en la blockchain tendría que pagar por cada 10.000 billetes vendidos a los usuarios finales, usando para esto un token en la plataforma Ethereum frente a otro en la plataforma Ardor. Éther valorado en 1000, 2000 y 3000 usd y Ardor valorado en 10, 20, 30 usd. ¿Alguien de aquí podría calcular esto?

martis [9:34 PM]

La tarifa de la child chain es de 0.01 ARDR. Por lo tanto, 0.1, 0.2, 0.3 USD por transacción.

Xavier [9:41 PM]

Una compañía que organiza grandes eventos regularmente podría emitir miles de tikets de media al día. ¿Le costaría siempre 1 Ardor agrupar 100 transacciones de la child chain? ¿Necesitaría 1000 Ardor para agrupar 100.000 transacciones de la child chain? ¿A un valor de 10 dólares por Ardor, costaría 10.000 usd emitir 100.000 boletos?

martis [9:57 PM]

Tus cálculos son correctos, pero no para emitir los tiquets. Para hacer 100.000 transacciones.

Xavier [9:58 PM]

Gracias Martis. Entonces, con un valor de 10 USD por Ardor, el emisor del tiket pagaría 10 céntimos por transacción. Con un valor de 20 usd por Ardor 20 céntimos, etc. Supongo que es un buen trato. No puedo hacer los cálculos equivalente a Ethereum. Aún no sé lo suficiente sobre eso.

martis [10:01 PM]

Creo que si ARDR valiese 10 USD, entonces las tasas podrían ser ajustadas por los desarrolladores.

Xavier [10:01 PM]

Me preguntaba acerca de eso también. Las tasas de forja se deberían poder reducir cuando el precio de Ardor aumenta para evitar que las transacciones sean demasiado caras. Sin embargo, la reducción de las tasas de forja puede ser un tema difícil.

CullensAnton [10:02 PM]

@Xavier eso ya sucedió. Las tasas ya han sido reducidas una vez anteriormente.

martis

Mi idea era más amplia, no solo las entradas de los conciertos, sino también el dinero interno del festival, en lugar del dinero fiat.

CullensAnton 

Sí, cuanto más amplia, mejor
Museos, piscinas, festivales, etc.

Xavier 

@martis: Ya estaba pensando en reemplazar monedas / cupones de alimentos / bebidas del evento con tokens.

martis

y puedes controlar los ingresos de los comerciantes dentro del festival y pedirles que paguen no por un sitio, sino por el % de sus ingresos durante el evento. Si el festival se encuentra en la UE, puede usar AEUR para pagos internos y crear activos, como entradas para el festival.

Xavier [10:12 PM]

El usuario final ni siquiera debería saber que una blockchain está de alguna manera involucrada en el servicio que está disfrutando.

(Volver al Índice)