Exemple #1
0
        Transaction ToDomain(Ztm.Data.Entity.Contexts.Main.Transaction entity)
        {
            // Common properties.
            var domain = Transaction.Create(this.zcoinNetwork);

            domain.Version  = (uint)entity.Version;
            domain.LockTime = (uint)entity.LockTime;

            // Outputs.
            foreach (var output in entity.Outputs)
            {
                domain.Outputs.Add(output.Value, output.Script);
            }

            // Inputs.
            foreach (var input in entity.Inputs)
            {
                domain.Inputs.Add(
                    outpoint: new OutPoint(input.OutputHash, (uint)input.OutputIndex),
                    scriptSig: input.Script,
                    sequence: (uint)input.Sequence
                    );
            }

            return(domain);
        }
Exemple #2
0
        Ztm.Data.Entity.Contexts.Main.Transaction ToEntity(Transaction tx)
        {
            var entity = new Ztm.Data.Entity.Contexts.Main.Transaction()
            {
                Hash     = tx.GetHash(),
                Version  = tx.Version,
                LockTime = tx.LockTime
            };

            // Outputs.
            for (int i = 0; i < tx.Outputs.Count; i++)
            {
                var output = new Ztm.Data.Entity.Contexts.Main.Output()
                {
                    TransactionHash = entity.Hash,
                    Index           = i,
                    Value           = tx.Outputs[i].Value,
                    Script          = tx.Outputs[i].ScriptPubKey,
                    Transaction     = entity
                };

                entity.Outputs.Add(output);
            }

            // Inputs.
            for (int i = 0; i < tx.Inputs.Count; i++)
            {
                var input = new Ztm.Data.Entity.Contexts.Main.Input()
                {
                    TransactionHash = entity.Hash,
                    Index           = i,
                    OutputHash      = tx.Inputs[i].PrevOut.Hash,
                    OutputIndex     = tx.Inputs[i].PrevOut.N,
                    Script          = tx.Inputs[i].ScriptSig,
                    Sequence        = tx.Inputs[i].Sequence,
                    Transaction     = entity
                };

                entity.Inputs.Add(input);
            }

            // Exodus payload.
            var exodusTx = tx.GetExodusTransaction();

            if (exodusTx != null)
            {
                entity.ExodusPayload = new Ztm.Data.Entity.Contexts.Main.ExodusPayload
                {
                    TransactionHash = tx.GetHash(),
                    Receiver        = exodusTx.Receiver.ToString(),
                    Sender          = exodusTx.Sender.ToString(),
                    Data            = this.exodusEncoder.Encode(exodusTx)
                };
            }

            return(entity);
        }
Exemple #3
0
        Ztm.Data.Entity.Contexts.Main.Transaction ToEntity(Transaction tx)
        {
            var entity = new Ztm.Data.Entity.Contexts.Main.Transaction()
            {
                Hash     = tx.GetHash(),
                Version  = tx.Version,
                LockTime = tx.LockTime
            };

            // Outputs.
            for (int i = 0; i < tx.Outputs.Count; i++)
            {
                var output = new Ztm.Data.Entity.Contexts.Main.Output()
                {
                    TransactionHash = entity.Hash,
                    Index           = i,
                    Value           = tx.Outputs[i].Value,
                    Script          = tx.Outputs[i].ScriptPubKey,
                    Transaction     = entity
                };

                entity.Outputs.Add(output);
            }

            // Inputs.
            for (int i = 0; i < tx.Inputs.Count; i++)
            {
                var input = new Ztm.Data.Entity.Contexts.Main.Input()
                {
                    TransactionHash = entity.Hash,
                    Index           = i,
                    OutputHash      = tx.Inputs[i].PrevOut.Hash,
                    OutputIndex     = tx.Inputs[i].PrevOut.N,
                    Script          = tx.Inputs[i].ScriptSig,
                    Sequence        = tx.Inputs[i].Sequence,
                    Transaction     = entity
                };

                entity.Inputs.Add(input);
            }

            return(entity);
        }
Exemple #4
0
        Transaction ToDomain(Ztm.Data.Entity.Contexts.Main.Transaction entity)
        {
            // Common properties.
            var domain = Transaction.Create(this.zcoinNetwork);

            domain.Version = (uint)entity.Version;
            domain.LockTime = (uint)entity.LockTime;

            // Outputs.
            foreach (var output in entity.Outputs)
            {
                domain.Outputs.Add(output.Value, output.Script);
            }

            // Inputs.
            foreach (var input in entity.Inputs)
            {
                domain.Inputs.Add(
                    outpoint: new OutPoint(input.OutputHash, (uint)input.OutputIndex),
                    scriptSig: input.Script,
                    sequence: (uint)input.Sequence
                );
            }

            if (entity.ExodusPayload != null)
            {
                var payload = entity.ExodusPayload;
                var sender = BitcoinAddress.Create(payload.Sender, this.zcoinNetwork);
                var receiver = BitcoinAddress.Create(payload.Receiver, this.zcoinNetwork);

                var exodusTx = this.exodusEncoder.Decode(sender, receiver, payload.Data);

                #pragma warning disable CS0618
                domain.SetExodusTransaction(exodusTx); // lgtm [cs/call-to-obsolete-method]
                #pragma warning restore CS0618
            }

            return domain;
        }
Exemple #5
0
        async Task StoreBlockAsync(Block block, int height)
        {
            var entity = new Ztm.Data.Entity.Contexts.Main.Block()
            {
                Height     = height,
                Hash       = block.GetHash(),
                Version    = block.Header.Version,
                Bits       = block.Header.Bits,
                Nonce      = block.Header.Nonce,
                Time       = block.Header.BlockTime.UtcDateTime,
                MerkleRoot = block.Header.HashMerkleRoot,
            };

            for (var i = 0; i < block.Transactions.Count; i++)
            {
                var tx = new Ztm.Data.Entity.Contexts.Main.Transaction()
                {
                    Hash     = block.Transactions[i].GetHash(),
                    Version  = block.Transactions[i].Version,
                    LockTime = block.Transactions[i].LockTime,
                };

                for (var j = 0; j < block.Transactions[i].Inputs.Count; j++)
                {
                    var input = block.Transactions[i].Inputs[j];

                    tx.Inputs.Add(new Ztm.Data.Entity.Contexts.Main.Input()
                    {
                        TransactionHash = tx.Hash,
                        Index           = j,
                        OutputHash      = input.PrevOut.Hash,
                        OutputIndex     = input.PrevOut.N,
                        Script          = input.ScriptSig,
                        Sequence        = input.Sequence,
                    });
                }

                for (var j = 0; j < block.Transactions[i].Outputs.Count; j++)
                {
                    var output = block.Transactions[i].Outputs[j];

                    tx.Outputs.Add(new Ztm.Data.Entity.Contexts.Main.Output()
                    {
                        TransactionHash = tx.Hash,
                        Index           = j,
                        Value           = output.Value,
                        Script          = output.ScriptPubKey,
                    });
                }

                entity.Transactions.Add(new Ztm.Data.Entity.Contexts.Main.BlockTransaction()
                {
                    BlockHash       = entity.Hash,
                    TransactionHash = tx.Hash,
                    Index           = i,
                    Transaction     = tx,
                });
            }

            using (var db = this.db.CreateDbContext())
            {
                await db.Blocks.AddAsync(entity);

                await db.SaveChangesAsync();
            }
        }