1.1.3 Registrar la transacción con la aplicación

const { Application, genesisBlockDevnet, configDevnet } = require('lisk-sdk');
const LightAlarmTransaction = require('../transactions/light-alarm');           

configDevnet.app.label = 'lisk-transport';

const app = new Application(genesisBlockDevnet, configDevnet);

app.registerTransaction(LightAlarmTransaction);                                 

app
    .run()
    .then(() => app.logger.info('App started...'))
    .catch(error => {
        console.error('Faced error in application', error);
        process.exit(1);
    });

Los siguientes puntos a continuación se tratan en esta sección

🔴 La forma de aplicar los tipos de transacciones que falta RegisterPacket, StartTransporty FinishTransport.

🔴 Cómo almacenar en caché varias cuentas en el preparepaso.

🔴 Cómo implementar un sistema de confianza simple.

🔴 Cómo bloquear fondos en una cuenta.

🔴 Cómo ejecutar una primera prueba completa del sistema de seguimiento de la cadena de suministro.

Se recomienda ver el diagrama en la página de Introducción , que ayudará al usuario a tener una visión general del taller.

🔴 packetId: El ID de la cuenta del paquete (registrada en Raspberry Pi)

🔴 postage: El franqueo se refiere a una cantidad de tokens LSK que el transportista recibe tras la entrega exitosa del paquete. El franqueo se almacena en el campo de activos de la cuenta del paquete.

🔴 security: La seguridad se refiere a una serie de tokens LSK que el operador debe bloquear como "seguridad" antes de que el paquete pueda aceptarse para su entrega. Tras la entrega exitosa, la seguridad se desbloqueará nuevamente para el saldo del transportista.

🔴 minTrust: Esta propiedad de fideicomiso mínima se ha introducido para realizar un seguimiento de los transportistas que se comportan bien / funcionan. Siempre que un transportista entregue con éxito un paquete, su confianza se incrementará en un factor de uno. El propietario del paquete puede establecer un nivel de confianza mínimo para un transportista antes de aceptar el paquete para su entrega. Si un transportista tiene una confianza menor que el nivel de confianza mínimo requerido, no es posible aceptar el paquete para la entrega.

🔴 recipientId: Tenga en cuenta que este es un campo muy importante, ya que establece el destinatario real que recibirá el paquete.

Para lo RegisterPacketTransaction siguiente, la siguiente guía recorre la función undoAsset()  y explica cómo se puede lograr; y, a su vez, permite al usuario implementar un pequeño fragmento de código que se describe a continuación:

Contenido de register-packet.js

const { BaseTransaction, TransactionError, utils } = require('@liskhq/lisk-transactions'); /** * Register new package for sender and update package account. */ class RegisterPacketTransaction extends BaseTransaction { static get TYPE () { return 20; } static get FEE () { return '0'; }; /* Prepare function stores both sender and packet account in

the cache so it is possible to modify the accounts during the `applyAsset` and `undoAsset`

steps. */ async prepare(store) { await store.account.cache([ { address: this.asset.packetId, }, { senderPublicKey: this.senderPublicKey, } ]); } /* Static checks for presence and correct datatypes of

transaction parameters in asset field like `minTrust`, `security`, `postage`, etc. */ validateAsset() { const errors = []; if (!this.asset.packetId || typeof this.asset.packetId !== 'string') { errors.push( new TransactionError( 'Invalid "asset.packetId" defined on transaction', this.id, '.asset.packetId', this.asset.packetId ) ); } if (!this.asset.postage || typeof this.asset.postage !== 'string') { errors.push( new TransactionError( 'Invalid "asset.postage" defined on transaction', this.id, '.asset.postage', this.asset.postage, 'A string value', ) ); } if (!this.asset.security || typeof this.asset.security !== 'string') { errors.push( new TransactionError( 'Invalid "asset.security" defined on transaction', this.id, '.asset.security', this.asset.security, 'A string value', ) ); } if (typeof this.asset.minTrust !== 'number' ||

isNaN(parseFloat(this.asset.minTrust)) || !isFinite(this.asset.minTrust)) { errors.push( new TransactionError( 'Invalid "asset.minTrust" defined on transaction', this.id, '.asset.minTrust', this.asset.minTrust, 'A number value', ) ); } return errors;

applyAsset(store) { const errors = []; /* Retrieve packet account from key-value store. */ const packet = store.account.get(this.asset.packetId); /* Check if packet account already has a status assigned. If yes, then this means the package is already registered

so an error is thrown. */ if (!packet.asset.status) { /* --- Modify sender account --- */ /** * Update the sender account: * - Deduct the postage from senders' account balance */ const sender = store.account.get(this.senderId); /* Deduct the defined postage from the sender's account balance. */ const senderBalancePostageDeducted = new utils.BigNum(sender.balance).sub( new utils.BigNum(this.asset.postage) ); /* Save the updated sender account with the new balance into the

key-value store. */ const updatedSender = { ...sender, balance: senderBalancePostageDeducted.toString(), }; store.account.set(sender.address, updatedSender); /* --- Modify packet account --- */ /** * Update the packet account: * - Add the postage to the packet account balance * - Add all important data about the packet inside

the asset field: * - recipient: ID of the packet recipient * - sender: ID of the packet sender * - carrier: ID of the packet carrier * - security: Number of tokens the carrier

needs to lock during

the transport of the packet * - postage: Number of tokens the sender needs

to pay for transportation

of the packet * - minTrust: Minimal trust that is needed to

be carrier for the packet * - status: Status of the transport

(pending|ongoing|success|fail) */ /* Add the postage now to the packet's account

balance. */ const packetBalanceWithPostage =

new utils.BigNum(packet.balance).add( new utils.BigNum(this.asset.postage) ); const updatedPacketAccount = { ...packet, ...{ balance: packetBalanceWithPostage.toString(), asset: { recipient: this.asset.recipientId, sender: this.senderId, security: this.asset.security, postage: this.asset.postage, minTrust: this.asset.minTrust, status: 'pending', carrier: null } } }; store.account.set(packet.address, updatedPacketAccount); } else { errors.push( new TransactionError( 'packet has already been registered', packet.asset.status ) ); } return errors;

undoAsset(store) { const errors = []; /* UndoAsset function tells the blockchain how to rollback changes

made in the applyAsset function. The original balance for both the sender

and package account is restored. In addtion, the `asset` field for the package

account to `null` is reset,

as it did not hold any previous data.*/ /* --- Revert sender account --- */ const sender = store.account.get(this.senderId); const senderBalanceWithPostage = new utils.BigNum(sender.balance).add( new utils.BigNum(this.asset.postage) ); const updatedSender = { ...sender, balance: senderBalanceWithPostage.toString() }; store.account.set(sender.address, updatedSender); /* --- Revert packet account --- */ const packet = store.account.get(this.asset.packetId); /* something is missing here */ store.account.set(packet.address, originalPacketAccount); return errors; } } module.exports = RegisterPacketTransaction;

Tarea: Completar la implementación de la función undoAsset.

Tenga en cuenta que falta una pequeña parte de la lógica por la cual la cuenta del paquete se restableció a su estado original.Ahora trata de poner en práctica la lógica falta de undoAsset()revirtiendo los pasos de la función applyAsset(). Importante: Para verificar la implementación de undoAsset(), compárelo con la solución .

const carrierBalanceWithoutSecurity = carrierBalance.sub(packetSecurity);

Este fragmento debe insertarse dos veces: una vez en transaction/light-alarm.jsla máquina local, y también en light-alarm.jsla frambuesa pi.h

const packet = store.account.get(this.senderId); if (packet.asset.status !== 'ongoing' && packet.asset.status !== 'alarm') { errors.push( new TransactionError( 'Transaction invalid because delivery is not "ongoing".', this.id, 'packet.asset.status', packet.asset.status, `Expected status to be equal to "ongoing" or "alarm"`, ) ); return errors; }

Registre todos los tipos de transacciones con la aplicación de nodo

const { Application, genesisBlockDevnet, configDevnet } = require('lisk-sdk'); const RegisterPacketTransaction = require('../transactions/register-packet'); const StartTransportTransaction = require('../transactions/start-transport'); const FinishTransportTransaction = require('../transactions/finish-transport'); const LightAlarmTransaction = require('../transactions/light-alarm'); configDevnet.app.label = 'lisk-transport'; configDevnet.modules.http_api.access.public = true; const app = new Application(genesisBlockDevnet, configDevnet); app.registerTransaction(RegisterPacketTransaction); app.registerTransaction(StartTransportTransaction); app.registerTransaction(FinishTransportTransaction); app.registerTransaction(LightAlarmTransaction); app .run() .then(() => app.logger.info('App started...')) .catch(error => { console.error('Faced error in application', error); process.exit(1); });

Pruébelo en la aplicación cliente

npm install pm2 -g
pm2 startup

pm2 start --name lightAlarm index.js

pm2 save

const app = new Application(genesisBlockDevnet, { modules: { network: { seedPeers: [{ ip: '1.2.3.4', wsPort: 5000}] } } });

De forma predeterminada, la lista de delegados de forja está vacía.

2.4. Conectar nodos y verificar