コード例 #1
0
            static public void handleWalletStateChunk(byte[] data, RemoteEndpoint endpoint)
            {
                using (MemoryStream m = new MemoryStream(data))
                {
                    using (BinaryReader reader = new BinaryReader(m))
                    {
                        ulong block_num   = reader.ReadIxiVarUInt();
                        int   chunk_num   = (int)reader.ReadIxiVarUInt();
                        int   num_wallets = (int)reader.ReadIxiVarUInt();
                        if (num_wallets > CoreConfig.walletStateChunkSplit)
                        {
                            Logging.error(String.Format("Received {0} wallets in a chunk. ( > {1}).",
                                                        num_wallets, CoreConfig.walletStateChunkSplit));
                            return;
                        }
                        Wallet[] wallets = new Wallet[num_wallets];
                        for (int i = 0; i < num_wallets; i++)
                        {
                            int    w_idLen = (int)reader.ReadIxiVarUInt();
                            byte[] w_id    = reader.ReadBytes(w_idLen);

                            int       w_balanceLen    = (int)reader.ReadIxiVarUInt();
                            byte[]    w_balance_bytes = reader.ReadBytes(w_balanceLen);
                            IxiNumber w_balance       = new IxiNumber(new BigInteger(w_balance_bytes));

                            wallets[i] = new Wallet(w_id, w_balance);

                            int w_dataLen = (int)reader.ReadIxiVarUInt();
                            if (w_dataLen > 0)
                            {
                                byte[] w_data = reader.ReadBytes(w_dataLen);
                                wallets[i].data = w_data;
                            }

                            int w_publickeyLen = (int)reader.ReadIxiVarUInt();
                            if (w_publickeyLen > 0)
                            {
                                byte[] w_publickey = reader.ReadBytes(w_publickeyLen);
                                wallets[i].publicKey = w_publickey;
                            }
                        }
                        WsChunk c = new WsChunk
                        {
                            chunkNum = chunk_num,
                            blockNum = block_num,
                            wallets  = wallets
                        };
                        Node.blockSync.onWalletChunkReceived(c);
                    }
                }
            }
コード例 #2
0
            // Sends a single wallet chunk
            public static void sendWalletStateChunk(RemoteEndpoint endpoint, WsChunk chunk)
            {
                using (MemoryStream m = new MemoryStream())
                {
                    using (BinaryWriter writer = new BinaryWriter(m))
                    {
                        writer.WriteIxiVarInt(chunk.blockNum);
                        writer.WriteIxiVarInt(chunk.chunkNum);
                        writer.WriteIxiVarInt(chunk.wallets.Length);
                        foreach (Wallet w in chunk.wallets)
                        {
                            writer.WriteIxiVarInt(w.id.Length);
                            writer.Write(w.id);
                            byte[] balance_bytes = w.balance.getAmount().ToByteArray();
                            writer.WriteIxiVarInt(balance_bytes.Length);
                            writer.Write(balance_bytes);

                            if (w.data != null)
                            {
                                writer.WriteIxiVarInt(w.data.Length);
                                writer.Write(w.data);
                            }
                            else
                            {
                                writer.WriteIxiVarInt((int)0);
                            }

                            if (w.publicKey != null)
                            {
                                writer.WriteIxiVarInt(w.publicKey.Length);
                                writer.Write(w.publicKey);
                            }
                            else
                            {
                                writer.WriteIxiVarInt((int)0);
                            }
                        }
#if TRACE_MEMSTREAM_SIZES
                        Logging.info(String.Format("NetworkProtocol::sendWalletStateChunk: {0}", m.Length));
#endif

                        endpoint.sendData(ProtocolMessageCode.walletStateChunk, m.ToArray());
                    }
                }
            }