import { Identities } from “@arkecosystem/crypto”;

import { Identities, Transactions } from “@arkecosystem/crypto”;// Now, we’ll examine the relevant part of our existing generateState function to see what happens when a game is won or tied:if (outcome !== “ongoing”) {
    break;
}

if (outcome !== "ongoing") {
    if (outcome === "tie") {
        this.pay(address, players, wager);
    } else {
        this.pay(address, players[outcome], wager * 2);
    }
    break;
}

private pay(sender: string, recipient: string | object, amount: number) {
    const wallet = app.resolvePlugin("database").walletManager.findById(sender);        if (wallet.nonce.toString() !== "0") {
        return;
    }    const passphrase = this.addresses[sender];
    const publicKey = Identities.PublicKey.fromPassphrase(passphrase);
    const fee = "1000000";
    const payAmount = (amount — parseInt(fee)).toString();
    let transaction;        if (typeof recipient === "string") {
        transaction = Transactions.BuilderFactory.transfer().nonce("1").senderPublicKey(publicKey).recipientId(recipient).fee(fee).amount(payAmount).vendorField("You won the game, congratulations!");
    } else {
        transaction = Transactions.BuilderFactory.multiPayment().nonce("1").senderPublicKey(publicKey).fee(fee).vendorField("The game was tied. Here is your wager!");
        transaction.addPayment(recipient[1], payAmount);
        transaction.addPayment(recipient[2], payAmount);
    }        const signedTransaction = transaction.sign(passphrase).build();
    app.resolvePlugin("p2p").getMonitor().broadcastTransactions([signedTransaction]);
}

const games = JSON.parse(runtime.globalVars.JSON);
const newGames = [];
const existingGames = [];
const ourGames = [];for (const address of Object.keys(games)) {
    const game = games[address];        if (game.players[2]) {
        existingGames.push({ address, game });                if (game.players[1] === runtime.globalVars.ValidatedAddress || game.players[2] === runtime.globalVars.ValidatedAddress) 
            ourGames.push({ address, game });
        }
    } else {
        newGames.push({ address, game });
    }
}let html = "";for (const game of newGames) { 
    const wager = (game.game.wager / 100000000);
    html += "<div>New game by " + game.game.players[1] + " for " + wager + runtime.globalVars.Symbol + " (<a href='ark:" + game.address + "&amount=" + wager + "'>Join</a>)</div>";
}document.getElementById("NewIframe").contentWindow.document.body.innerHTML = html;
html = "";for (const game of existingGames) {
    const wager = game.game.wager / 100000000;
    html += "<div>Game between " + game.game.players[1] + " and " + game.game.players[2] + " for " + wager + runtime.globalVars.Symbol + "</div>";
}document.getElementById("ExistingIframe").contentWindow.document.body.innerHTML = html;
html = "";for (const game of ourGames) {
    const wager = game.game.wager / 100000000;
    html += "<div>Game between " + (game.game.players[1] === runtime.globalVars.ValidatedAddress ? "you" : game.game.players[1]) + " and " + (game.game.players[2] === runtime.globalVars.ValidatedAddress ? "you" : game.game.players[2]) + " for " + wager + runtime.globalVars.Symbol + "</div>";
}document.getElementById("OurIframe").contentWindow.document.body.innerHTML = html;

emitter.on(ApplicationEvents.TransactionApplied, transaction => {
    if (this.addresses[transaction.recipientId]) {
        for (const websocket of server.clients) {
            // @ts-ignore
            if (websocket.readyState === WebSocket.OPEN && websocket.address === transaction.recipientId) {
                websocket.send(JSON.stringify({ transaction }));
            }
        }
    }
});

while (!(await app.resolvePlugin(“database”).transactionsBusinessRepository.findById(transaction.id))) {
    await delay(100);
}await this.generateState(transaction.recipientId);

private async generateState(address: string) {
    const database = app.resolvePlugin("database");
    const publicKey = Identities.PublicKey.fromPassphrase(this.addresses[address]);        const transactions: any[] = await Promise.all(
        (await database.transactionsBusinessRepository.search({
            limit: 0,
            walletAddress: address,
            publicKey
        })).rows.map(async transaction => ({
            amount: transaction.amount,
            recipientId: transaction.recipientId,
            senderId: Identities.Address.fromPublicKey(transaction.senderPublicKey, app.getConfig().get("network.pubKeyHash")),
            timestamp: (await database.blocksBusinessRepository.findById(transaction.blockId)).timestamp,
            vendorField: transaction.vendorField ? transaction.vendorField.toString().trim().toUpperCase() : null
        })
    ));        transactions.sort((a: any, b: any) => (a.timestamp > b.timestamp) ? 1 : ((b.timestamp > a.timestamp) ? -1 : 0));        const players = { 1: null, 2: null };
    let wager = 0;
    for (const transaction of transactions) {
        if (transaction.senderId !== address && transaction.amount >= 10000000) {
            players[1] = transaction.senderId;
            wager = transaction.amount;
            break;
        }
    }        if (!players[1]) {
        return;
    }        for (const transaction of transactions) {
        if (transaction.senderId !== address && transaction.senderId !== players[1] && transaction.amount === wager) {
            players[2] = transaction.senderId;
            break;
        }
    }        this.gameStates[address] = { players, wager };
}

websocket.send(networkData);

websocket.send(JSON.stringify({ games: JSON.stringify(this.gameStates) }));
// This will send all our game states to the client as soon as it connects.// Lastly, find:
for (const websocket of server.clients) {
    // @ts-ignore
    if (websocket.readyState === WebSocket.OPEN && websocket.address === transaction.recipientId) {
        websocket.send(JSON.stringify({ transaction }));
    }
}

const state = JSON.stringify({ games: JSON.stringify(this.gameStates) });for (const websocket of server.clients) {
    if (websocket.readyState === WebSocket.OPEN) {
        websocket.send(state);                // @ts-ignore
        if (websocket.address === transaction.recipientId) {
            websocket.send(JSON.stringify({ transaction }));
        }
    }
}

lerna add fluidb — dev

import delay from "delay";
import FluiDB from "fluidb";// Replace our previous implementation with FluiDB. Find:
private addresses = {};// Replace it with:
private addresses = new FluiDB(`${process.env.CORE_PATH_DATA}/generated-addresses`);
private gameStates = {};

public start(options: any) {// Make it asynchronous by adding the async keyword, so it looks like this:
public async start(options: any) {

const networkData = JSON.stringify({ networkVersion: config.get(“network.pubKeyHash”) });

const networkData = JSON.stringify({
    networkVersion: config.get("network.pubKeyHash"),
    symbol: config.get("network.client.symbol")
});//On the next line, add the following block of code:
for (const address of Object.keys(this.addresses)) {
    this.generateState(address);
}