Part 3: A simple supply chain management system

const {
    BaseTransaction,
    TransactionError
} = require('@liskhq/lisk-transactions');

/**
 * Register new package for sender and update package account.
 */
class RegisterPacketTransaction extends BaseTransaction {

    static get TYPE () {
        return 20;
    }

    async prepare(store) {
        await store.account.cache([
            {
                address: this.asset.packetId,
            },
            {
                address: this.senderId,
            }
        ]);
    }

    validateAsset() {
        // Static checks for presence of `packetId`, `postage`, `security`, and `minTrust`.
        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;
    }

    async applyAsset(store) {
        const errors = [];
        const packet = await store.account.get(this.asset.packetId);

        if (!packet.asset.status) {
            /* --- Modify sender account --- */
            /**
             * Update the sender account:
             * - Deduct the postage from senders' account balance
             */
            const sender = await store.account.get(this.senderId);
            sender.balance = BigInt(sender.balance) - BigInt(this.asset.postage);

            store.account.set(sender.address, sender);

            /* --- 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)
             */
            packet.balance = packet.balance + BigInt(this.asset.postage);

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

    async undoAsset(store) {
        const errors = [];

        /* --- Revert sender account --- */
        const sender = await store.account.get(this.senderId);
        sender.balance = sender.balance + BigInt(this.asset.postage);

        store.account.set(sender.address, sender);

        /* --- Revert packet account --- */
        const packet = await store.account.get(this.asset.packetId);
        packet.balance = BigInt("0");
        packet.asset = null;
        store.account.set(packet.address, packet);

        return errors;
    }

}

module.exports = RegisterPacketTransaction;

const {
    BaseTransaction,
    TransactionError
} = require('@liskhq/lisk-transactions');

class StartTransportTransaction extends BaseTransaction {

    static get TYPE () {
        return 21;
    }

    async prepare(store) {
        await store.account.cache([
            {
                address: this.asset.recipientId,
            },
            {
                address: this.senderId,
            }
        ]);
    }

    validateAsset() {
        const errors = [];

        return errors;
    }

    async applyAsset(store) {
        const errors = [];
        const packet = await store.account.get(this.asset.recipientId);
        if (packet.asset.status === "pending"){
            const carrier = await store.account.get(this.senderId);
            // If the carrier has the trust to transport the packet
            const carrierTrust = carrier.asset.trust ? carrier.asset.trust : '0';
            if (BigInt(packet.asset.minTrust) <= BigInt(carrierTrust) && carrier.balance >= BigInt(packet.asset.security)) {
                /**
                 * Update the Carrier account:
                 * - Lock security inside the account
                 * - Remove the security from balance
                 * - initialize carriertrust, if not present already
                 */
                carrier.balance = { /* Write your code here */ };
                carrier.asset = { /* Write your code here */ };
                store.account.set(carrier.address, carrier);
                /**
                 * Update the Packet account:
                 * - Set status to "ongoing"
                 * - set carrier to ID of the carrier
                 */
                packet.asset.status = "ongoing";
                packet.asset.carrier = carrier.address;
                store.account.set(packet.address, packet);
            } else {
                errors.push(
                    new TransactionError(
                        'carrier has not enough trust to deliver the packet, or not enough balance to pay the security',
                        packet.asset.minTrust,
                        carrier.asset.trust,
                        packet.asset.security,
                        carrier.balance.toString()
                    )
                );
            }
        } else {
            errors.push(
                new TransactionError(
                    'packet status needs to be "pending"',
                    packet.asset.status
                )
            );
        }

        return errors;
    }

    async undoAsset(store) {
        const errors = [];
        const packet = await store.account.get(this.asset.packetId);
        const carrier = await store.account.get(this.senderId);
        /* --- Revert carrier account --- */
        carrier.balance = carrier.balance + BigInt(packet.asset.security);

        store.account.set(carrier.address, carrier);
        /* --- Revert packet account --- */
        packet.asset = {
            deliveryStatus: "pending",
            carrier: null
        };
        store.account.set(packet.address, packet);
        return errors;
    }

}

module.exports = StartTransportTransaction;

async applyAsset(store) {
    const errors = [];
    let packet = await store.account.get(this.asset.packetId);
    let carrier = await store.account.get(packet.asset.carrier);
    let sender = await store.account.get(packet.asset.sender);
    // if the transaction has been signed by the packet recipient
    if (this.senderId === packet.asset.recipient) {
        // if the packet status isn't "ongoing" or "alarm"
        if (packet.asset.status !==  "ongoing" && packet.asset.status !== "alarm") {
            errors.push(
                new TransactionError(
                    'FinishTransport can only be triggered, if packet status is "ongoing" or "alarm" ',
                    this.id,
                    'ongoing or alarm',
                    this.asset.status
                )
            );
            return errors;
        }
        // if the transport was a success
        if ( this.asset.status === "success") {
            /**
             * Update the Carrier account:
             * - Unlock security
             * - Add postage & security to balance
             * - Earn 1 trustpoint
             */
            carrier.balance = carrier.balance + BigInt(packet.asset.security) + BigInt(packet.asset.postage);
            const trustInc = carrier.asset.trust ? BigInt(carrier.asset.trust) + BigInt(1) : BigInt(1);

            carrier.asset = {
                ...carrier.asset,
                trust: trustInc.toString(),
                lockedSecurity: null
            };

            store.account.set(carrier.address, carrier);
            /**
             * Update the Packet account:
             * - Remove postage from balance
             * - Change status to "success"
             */
            packet.balance = BigInt(0);
            packet.asset = {
                ...packet.asset,
                status: 'success'
            }

            store.account.set(packet.address, packet);
            return errors;
        }
        // if the transport failed
        /**
         * Update the Sender account:
         * - Add postage and security to balance
         */
        sender.balance = sender.balance + BigInt(packet.asset.security) + BigInt(packet.asset.postage);

        store.account.set(sender.address, sender);
        /**
         * Update the Carrier account:
         * - Reduce trust by 1
         * - Set lockedSecurity to 0
         */
        const trustDec = carrier.asset.trust ? BigInt(carrier.asset.trust) - BigInt(1) : BigInt(-1);
        carrier.asset = {
            ...carrier.asset,
            trust: trustDec.toString(),
            lockedSecurity: null
        };

        store.account.set(carrier.address, carrier);
        /**
         * Update the Packet account:
         * - set status to "fail"
         * - Remove postage from balance
         */
        packet.balance = BigInt('0');
        packet.asset = {
            ...packet.asset,
            status: 'fail'
        };

        store.account.set(packet.address, packet);

        return errors;
    }
    errors.push(
        new TransactionError(
            'FinishTransport transaction needs to be signed by the recipient of the packet',
            this.id,
            '.asset.recipient',
            this.asset.recipient
        )
    );
    return errors;
}