Topic: 🔹🅰RK🔹[ANN] ARK - Криптoвaлютнaя Экocиcтeмa🔹 ICO Зaвepшeнo (Read 104129 times)

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 += "
New game by " + game.game.players[1] + " for " + wager + runtime.globalVars.Symbol + " (Join)
";
}document.getElementById("NewIframe").contentWindow.document.body.innerHTML = html;
html = "";for (const game of existingGames) {
    const wager = game.game.wager / 100000000;
    html += "
Game between " + game.game.players[1] + " and " + game.game.players[2] + " for " + wager + runtime.globalVars.Symbol + "
";
}document.getElementById("ExistingIframe").contentWindow.document.body.innerHTML = html;
html = "";for (const game of ourGames) {
    const wager = game.game.wager / 100000000;
    html += "
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 + "
";
}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);
}

const emitter = app.resolvePlugin("event-emitter"); 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 }));
            }
        }
    }
});

import { ApplicationEvents } from “@arkecosystem/core-event-emitter”;

export const defaults = {
    enabled: true,
    host: "0.0.0.0",
    port: 10000
};

import * as WebSocket from “ws”;

public start(options: any) {
    this.logger.info("Initialization of dApp");
}

public start(options: any) {
    try {
        const server = new WebSocket.Server({ host: options.host, port: options.port });
        this.logger.info(`Connect 4 WebSocket server listening on ws://${options.host}:${options.port}`);
    } catch (error) {
        this.logger.error(`Connect 4 WebSocket server could not start: ${error.message}`);
    }
}

const config = app.getConfig();
const networkData = JSON.stringify({ networkVersion: config.get("network.pubKeyHash") });

server.on("connection", websocket => {
    websocket.send(networkData);
});

1|ark-relay | [2020–02–17 19:00:00.000] INFO : Connect 4 WebSocket server listening on ws://0.0.0.0:10000

websocket.on("message", message => {
    try {
        const data = JSON.parse(message.toString());
        if (data.action === "new") {
            const { address, passphrase } = this.generateAddress();
            this.addresses[address] = passphrase;
            // @ts-ignore
            websocket.address = address;
            websocket.send(JSON.stringify({ address }));
        }
    } catch (error) {
        this.logger.error(error.stack);
    }
});

private generateAddress() {
    const passphrase = generateMnemonic();
    const address = Identities.Address.fromPassphrase(passphrase);
    return { address, passphrase };
}

import { generateMnemonic } from “bip39”;
import { Identities } from “@arkecosystem/crypto”;
// Lastly we add a new addresses private variable immediately above // the private readonly logger line:
private addresses = {};

if (localVars.address.length === 34) {try {const networkVersion = bs58check.decode(localVars.address).readUInt8(0);if (networkVersion === runtime.globalVars.networkVersion) {runtime.setReturnValue(1);}} catch (error) {// the address is invalid}}

npm install -g browserify uglify-jsnpm 
install bs58check
browserify — standalone bs58check -r bs58check | uglifyjs > bs58check.min.js

“@arkecosystem/core-api”: {cache: { enabled: false },…},

CORE_API_NO_ESTIMATED_TOTAL_COUNT=true

“@arkecosystem/core-p2p”: {server: {…minimumNetworkReach: 0,},

const MESSAGE_TYPE = 101;const MESSAGE_TYPE_GROUP = 1001;

public static getSchema(): Transactions.schemas.TransactionSchema {return schemas.extend(schemas.transactionBaseSchema, {…}}

const { addressBuffer, addressError } = Identities.Address.toBuffer(data.recipientId);
options.addressError = addressError;
buffer.append(addressBuffer);

data.recipientId = Identities.Address.fromBuffer(buf.readBytes(21).toBuffer());

const { data }: Interfaces.ITransaction = transaction;const { message }: { message: string } = data.asset.messageData;if (!message) {throw new MessageTransactionAssetError();}await super.throwIfCannotBeApplied(transaction, wallet, databaseWalletManager);

constructor() {super();this.data.type = MessageTransaction.type;this.data.typeGroup = MessageTransaction.typeGroup;this.data.version = 2;this.data.fee = Utils.BigNumber.make("1000000");this.data.amount = Utils.BigNumber.ZERO;this.data.asset = { messageData: {} };this.data.recipientId = undefined;};

public messageData(message: string): MessageTransactionBuilder {this.data.asset.messageData = {message,};};

const struct: Interfaces.ITransactionData = super.getStruct();struct.amount = this.data.amount;struct.asset = this.data.asset;struct.recipientId = this.data.recipientId;return struct;};

import “jest-extended”;
import { Managers, Transactions } from “@arkecosystem/crypto”;
import { MessageTransactionBuilder } from “../src/builders”;
import { MessageTransaction } from “../src/transactions”;

Managers.configManager.setFromPreset(“testnet”);
Managers.configManager.setHeight(2);

Transactions.TransactionRegistry.registerTransactionType(MessageTransaction);

describe(“Test builder”, () => {
      it(“should verify correctly”, () => {
      const builder = new MessageTransactionBuilder();
      const tx = builder
         .messageData(“SomeMessage”)
         .nonce(“3”)
         .recipientId(“AYeceuGa7tTsyG6jgq7X6qKdoXt9iJJKN6”)        .sign(“clay harbor enemy utility margin pretty hub comic piece  aerobic umbrella acquire”);
      expect(tx.build().verified).toBeTrue();
      expect(tx.verify()).toBeTrue();
      });
});

module.exports = {….“message-transaction”: {},};

import { encryptMessage, fetchRemoteNonce, broadcastTransaction } from ‘./index’;import { Transactions } from ‘@arkecosystem/crypto’;import { ITransactionData, IPostTransactionResponse } from ‘../interfaces’;import { MessageTransaction } from ‘../custom-transactions/message-transaction/transactions’;import { MessageTransactionBuilder } from ‘../custom-transactions/message-transaction/builders’;

Transactions.TransactionRegistry.registerTransactionType(MessageTransaction);

const NETWORK = Number(process.env.REACT_APP_NETWORK);

const createMessageTransaction = async (recipientId: string,encryptedMessage: string,passphrase: string,senderId: string): Promise => {const nonce = await fetchRemoteNonce(senderId);const tx = new MessageTransactionBuilder().network(NETWORK).recipientId(recipientId).messageData(encryptedMessage).nonce(nonce).sign(passphrase);return tx.getStruct();};export const sendMessage = async (recipientId: string,text: string,channelPassphrase: string,userPassphrase: string,userAddress: string): Promise => {const encryptedMessage = encryptMessage(text, channelPassphrase);try {const tx = await createMessageTransaction(recipientId,encryptedMessage,userPassphrase,userAddress);return broadcastTransaction(tx);} catch (err) {console.error(err);}};

import { Providers } from "@arkecosystem/core-kernel";
import { Server } from "@hapi/hapi";
export class ServiceProvider extends Providers.ServiceProvider {
    public async register(): Promise {
        this.app.bind("api").toConstantValue(new Server());
    }
public async boot(): Promise {
        await this.app.get("api").start();
    }
public async dispose(): Promise {
        await this.app.get("api").stop();
    }
}