public ProviderSession Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { _ = rlpStream.ReadSequenceLength(); var id = rlpStream.DecodeKeccak(); var depositId = rlpStream.DecodeKeccak(); var dataAssetId = rlpStream.DecodeKeccak(); var consumerAddress = rlpStream.DecodeAddress(); var consumerNodeId = new PublicKey(rlpStream.DecodeByteArray()); var providerAddress = rlpStream.DecodeAddress(); var providerNodeId = new PublicKey(rlpStream.DecodeByteArray()); var state = (SessionState)rlpStream.DecodeInt(); var startUnitsFromProvider = rlpStream.DecodeUInt(); var startUnitsFromConsumer = rlpStream.DecodeUInt(); var startTimestamp = rlpStream.DecodeUlong(); var finishTimestamp = rlpStream.DecodeUlong(); var consumedUnits = rlpStream.DecodeUInt(); var unpaidUnits = rlpStream.DecodeUInt(); var paidUnits = rlpStream.DecodeUInt(); var settledUnits = rlpStream.DecodeUInt(); var graceUnits = rlpStream.DecodeUInt(); var dataAvailability = (DataAvailability)rlpStream.DecodeInt(); return(new ProviderSession(id, depositId, dataAssetId, consumerAddress, consumerNodeId, providerAddress, providerNodeId, state, startUnitsFromProvider, startUnitsFromConsumer, startTimestamp, finishTimestamp, consumedUnits, unpaidUnits, paidUnits, settledUnits, graceUnits, dataAvailability)); }
public DataAsset Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { var sequenceLength = rlpStream.ReadSequenceLength(); if (sequenceLength == 0) { return(null); } var id = rlpStream.DecodeKeccak(); var name = rlpStream.DecodeString(); var description = rlpStream.DecodeString(); var unitPrice = rlpStream.DecodeUInt256(); var unitType = (DataAssetUnitType)rlpStream.DecodeInt(); var minUnits = rlpStream.DecodeUInt(); var maxUnits = rlpStream.DecodeUInt(); var rules = Nethermind.Core.Encoding.Rlp.Decode <DataAssetRules>(rlpStream); var provider = Nethermind.Core.Encoding.Rlp.Decode <DataAssetProvider>(rlpStream); var file = rlpStream.DecodeString(); var queryType = (QueryType)rlpStream.DecodeInt(); var state = (DataAssetState)rlpStream.DecodeInt(); var termsAndConditions = rlpStream.DecodeString(); var kycRequired = rlpStream.DecodeBool(); var plugin = rlpStream.DecodeString(); return(new DataAsset(id, name, description, unitPrice, unitType, minUnits, maxUnits, rules, provider, file, queryType, state, termsAndConditions, kycRequired, plugin)); }
public DataAsset Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { try { rlpStream.ReadSequenceLength(); Keccak id = rlpStream.DecodeKeccak(); string name = rlpStream.DecodeString(); string description = rlpStream.DecodeString(); UInt256 unitPrice = rlpStream.DecodeUInt256(); DataAssetUnitType unitType = (DataAssetUnitType)rlpStream.DecodeInt(); uint minUnits = rlpStream.DecodeUInt(); uint maxUnits = rlpStream.DecodeUInt(); DataAssetRules rules = Serialization.Rlp.Rlp.Decode <DataAssetRules>(rlpStream); DataAssetProvider provider = Serialization.Rlp.Rlp.Decode <DataAssetProvider>(rlpStream); string file = rlpStream.DecodeString(); QueryType queryType = (QueryType)rlpStream.DecodeInt(); DataAssetState state = (DataAssetState)rlpStream.DecodeInt(); string termsAndConditions = rlpStream.DecodeString(); bool kycRequired = rlpStream.DecodeBool(); string plugin = rlpStream.DecodeString(); return(new DataAsset(id, name, description, unitPrice, unitType, minUnits, maxUnits, rules, provider, file, queryType, state, termsAndConditions, kycRequired, plugin)); } catch (Exception e) { throw new RlpException($"{nameof(DataAsset)} could not be deserialized", e); } }
public PingMessage Deserialize(byte[] msg) { (PingMessage Message, byte[] Mdc, byte[] Data)results = PrepareForDeserialization <PingMessage>(msg); RlpStream rlp = results.Data.AsRlpStream(); rlp.ReadSequenceLength(); int version = rlp.DecodeInt(); rlp.ReadSequenceLength(); byte[] sourceAddress = rlp.DecodeByteArray(); IPEndPoint source = GetAddress(sourceAddress, rlp.DecodeInt()); rlp.DecodeInt(); // UDP port rlp.ReadSequenceLength(); byte[] destinationAddress = rlp.DecodeByteArray(); IPEndPoint destination = GetAddress(destinationAddress, rlp.DecodeInt()); rlp.DecodeInt(); // UDP port long expireTime = rlp.DecodeLong(); PingMessage message = results.Message; message.SourceAddress = source; message.DestinationAddress = destination; message.Mdc = results.Mdc; message.Version = version; message.ExpirationTime = expireTime; return(message); }
public ConsumerSession Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { rlpStream.ReadSequenceLength(); Keccak id = rlpStream.DecodeKeccak(); Keccak depositId = rlpStream.DecodeKeccak(); Keccak dataAssetId = rlpStream.DecodeKeccak(); Address consumerAddress = rlpStream.DecodeAddress(); PublicKey consumerNodeId = new PublicKey(rlpStream.DecodeByteArray()); Address providerAddress = rlpStream.DecodeAddress(); PublicKey providerNodeId = new PublicKey(rlpStream.DecodeByteArray()); SessionState state = (SessionState)rlpStream.DecodeInt(); uint startUnitsFromProvider = rlpStream.DecodeUInt(); uint startUnitsFromConsumer = rlpStream.DecodeUInt(); ulong startTimestamp = rlpStream.DecodeUlong(); ulong finishTimestamp = rlpStream.DecodeUlong(); uint consumedUnits = rlpStream.DecodeUInt(); uint unpaidUnits = rlpStream.DecodeUInt(); uint paidUnits = rlpStream.DecodeUInt(); uint settledUnits = rlpStream.DecodeUInt(); uint consumedUnitsFromProvider = rlpStream.DecodeUInt(); DataAvailability dataAvailability = (DataAvailability)rlpStream.DecodeInt(); return(new ConsumerSession(id, depositId, dataAssetId, consumerAddress, consumerNodeId, providerAddress, providerNodeId, state, startUnitsFromProvider, startUnitsFromConsumer, startTimestamp, finishTimestamp, consumedUnits, unpaidUnits, paidUnits, settledUnits, consumedUnitsFromProvider, dataAvailability)); }
public DisconnectMessage Deserialize(byte[] bytes) { if (bytes.Length == 1) { return(new DisconnectMessage((DisconnectReason)bytes[0])); } if (bytes.SequenceEqual(breach1)) { return(new DisconnectMessage(DisconnectReason.Breach1)); } if (bytes.SequenceEqual(breach2)) { return(new DisconnectMessage(DisconnectReason.Breach2)); } RlpStream rlpStream = bytes.AsRlpStream(); rlpStream.ReadSequenceLength(); int reason = rlpStream.DecodeInt(); DisconnectMessage disconnectMessage = new DisconnectMessage(reason); return(disconnectMessage); }
public PaymentClaim Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { _ = rlpStream.ReadSequenceLength(); var id = rlpStream.DecodeKeccak(); var depositId = rlpStream.DecodeKeccak(); var assetId = rlpStream.DecodeKeccak(); var assetName = rlpStream.DecodeString(); var units = rlpStream.DecodeUInt(); var claimedUnits = rlpStream.DecodeUInt(); var unitsRange = Nethermind.Serialization.Rlp.Rlp.Decode <UnitsRange>(rlpStream); var value = rlpStream.DecodeUInt256(); var claimedValue = rlpStream.DecodeUInt256(); var expiryTime = rlpStream.DecodeUInt(); var pepper = rlpStream.DecodeByteArray(); var provider = rlpStream.DecodeAddress(); var consumer = rlpStream.DecodeAddress(); var transactions = Rlp.DecodeArray <TransactionInfo>(rlpStream); var transactionCost = rlpStream.DecodeUInt256(); var timestamp = rlpStream.DecodeUlong(); var status = (PaymentClaimStatus)rlpStream.DecodeInt(); var signature = SignatureDecoder.DecodeSignature(rlpStream); var paymentClaim = new PaymentClaim(id, depositId, assetId, assetName, units, claimedUnits, unitsRange, value, claimedValue, expiryTime, pepper, provider, consumer, signature, timestamp, transactions, status); if (status == PaymentClaimStatus.Claimed) { paymentClaim.SetTransactionCost(transactionCost); } return(paymentClaim); }
private static ParityTraceAction DecodeAction(RlpStream rlpStream) { ParityTraceAction action = new ParityTraceAction(); int sequenceLength = rlpStream.ReadSequenceLength(); if (rlpStream.ReadNumberOfItemsRemaining(rlpStream.Position + sequenceLength) == 3) { action.CallType = "reward"; action.RewardType = rlpStream.DecodeString(); action.Author = rlpStream.DecodeAddress(); action.Value = rlpStream.DecodeUInt256(); action.TraceAddress = Array.Empty <int>(); } else { action.CallType = rlpStream.DecodeString(); action.From = rlpStream.DecodeAddress(); action.To = rlpStream.DecodeAddress(); action.Value = rlpStream.DecodeUInt256(); action.Gas = rlpStream.DecodeLong(); action.Input = rlpStream.DecodeByteArray(); action.Result = new ParityTraceResult(); action.Result.Output = rlpStream.DecodeByteArray(); action.Result.GasUsed = rlpStream.DecodeLong(); action.TraceAddress = rlpStream.DecodeArray(c => c.DecodeInt()); int subtracesCount = rlpStream.DecodeInt(); action.Subtraces = new List <ParityTraceAction>(subtracesCount); for (int i = 0; i < subtracesCount; i++) { action.Subtraces.Add(DecodeAction(rlpStream)); } } return(action); }
public HelloMessage Deserialize(byte[] bytes) { RlpStream rlpStream = bytes.AsRlpStream(); rlpStream.ReadSequenceLength(); HelloMessage helloMessage = new HelloMessage(); helloMessage.P2PVersion = rlpStream.DecodeByte(); helloMessage.ClientId = string.Intern(rlpStream.DecodeString()); helloMessage.Capabilities = rlpStream.DecodeArray(ctx => { ctx.ReadSequenceLength(); string protocolCode = string.Intern(ctx.DecodeString()); int version = ctx.DecodeByte(); return(new Capability(protocolCode, version)); }).ToList(); helloMessage.ListenPort = rlpStream.DecodeInt(); byte[] publicKeyBytes = rlpStream.DecodeByteArray(); if (publicKeyBytes.Length != PublicKey.LengthInBytes && publicKeyBytes.Length != PublicKey.PrefixedLengthInBytes) { throw new NetworkingException($"Client {helloMessage.ClientId} sent an invalid public key format (length was {publicKeyBytes.Length})", NetworkExceptionType.HandshakeOrInit); } else { helloMessage.NodeId = new PublicKey(publicKeyBytes); } return(helloMessage); }
private Dictionary <Address, Tally> DecodeTally(RlpStream rlpStream) { rlpStream.ReadSequenceLength(); Dictionary <Address, Tally> tally = new Dictionary <Address, Tally>(); int length = rlpStream.DecodeInt(); for (int i = 0; i < length; i++) { Address address = rlpStream.DecodeAddress(); int votes = rlpStream.DecodeInt(); bool authorize = rlpStream.DecodeBool(); Tally tallyItem = new Tally(authorize); tallyItem.Votes = votes; tally[address] = tallyItem; } return(tally); }
public FaucetResponse Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { rlpStream.ReadSequenceLength(); FaucetRequestStatus status = (FaucetRequestStatus)rlpStream.DecodeInt(); FaucetRequestDetails request = Serialization.Rlp.Rlp.Decode <FaucetRequestDetails>(rlpStream); return(new FaucetResponse(status, request)); }
public DataAssetStateChangedMessage Deserialize(byte[] bytes) { RlpStream context = bytes.AsRlpStream(); context.ReadSequenceLength(); Keccak? dataAssetId = context.DecodeKeccak(); DataAssetState state = (DataAssetState)context.DecodeInt(); return(new DataAssetStateChangedMessage(dataAssetId, state)); }
public DataAvailabilityMessage Deserialize(byte[] bytes) { RlpStream context = bytes.AsRlpStream(); context.ReadSequenceLength(); Keccak? depositId = context.DecodeKeccak(); DataAvailability reason = (DataAvailability)context.DecodeInt(); return(new DataAvailabilityMessage(depositId, reason)); }
public static ContractCodesMessage Deserialize(RlpStream rlpStream) { ContractCodesMessage contractCodesMessage = new ContractCodesMessage(); rlpStream.ReadSequenceLength(); contractCodesMessage.RequestId = rlpStream.DecodeLong(); contractCodesMessage.BufferValue = rlpStream.DecodeInt(); contractCodesMessage.Codes = rlpStream.DecodeArray(stream => stream.DecodeByteArray()); return(contractCodesMessage); }
private static BlockBodiesMessage Deserialize(RlpStream rlpStream) { BlockBodiesMessage blockBodiesMessage = new BlockBodiesMessage(); rlpStream.ReadSequenceLength(); blockBodiesMessage.RequestId = rlpStream.DecodeLong(); blockBodiesMessage.BufferValue = rlpStream.DecodeInt(); blockBodiesMessage.EthMessage = Eth.V62.BlockBodiesMessageSerializer.Deserialize(rlpStream); return(blockBodiesMessage); }
public PingMsg Deserialize(byte[] msgBytes) { (PublicKey FarPublicKey, byte[] Mdc, byte[] Data)results = PrepareForDeserialization(msgBytes); RlpStream rlp = results.Data.AsRlpStream(); rlp.ReadSequenceLength(); int version = rlp.DecodeInt(); rlp.ReadSequenceLength(); ReadOnlySpan <byte> sourceAddress = rlp.DecodeByteArraySpan(); // TODO: please note that we decode only one field for port and if the UDP is different from TCP then // our discovery messages will not be routed correctly (the fix will not be part of this commit) rlp.DecodeInt(); // UDP port int tcpPort = rlp.DecodeInt(); // we assume here that UDP and TCP port are same IPEndPoint source = GetAddress(sourceAddress, tcpPort); rlp.ReadSequenceLength(); ReadOnlySpan <byte> destinationAddress = rlp.DecodeByteArraySpan(); IPEndPoint destination = GetAddress(destinationAddress, rlp.DecodeInt()); rlp.DecodeInt(); // UDP port long expireTime = rlp.DecodeLong(); PingMsg msg = new(results.FarPublicKey, expireTime, source, destination, results.Mdc); msg.Version = version; if (version == 4) { if (!rlp.HasBeenRead) { long enrSequence = rlp.DecodeLong(); msg.EnrSequence = enrSequence; } } else { // what do we do when receive version 5? } return(msg); }
public PongMsg Deserialize(byte[] msgBytes) { (PublicKey FarPublicKey, byte[] Mdc, byte[] Data)results = PrepareForDeserialization(msgBytes); RlpStream rlp = results.Data.AsRlpStream(); rlp.ReadSequenceLength(); rlp.ReadSequenceLength(); // GetAddress(rlp.DecodeByteArray(), rlp.DecodeInt()); rlp.DecodeByteArraySpan(); rlp.DecodeInt(); // UDP port (we ignore and take it from Netty) rlp.DecodeInt(); // TCP port byte[] token = rlp.DecodeByteArray(); long expirationTime = rlp.DecodeLong(); PongMsg msg = new(results.FarPublicKey, expirationTime, token); return(msg); }
public static GetBlockHeadersMessage Deserialize(RlpStream rlpStream) { GetBlockHeadersMessage message = new(); rlpStream.ReadSequenceLength(); byte[] startingBytes = rlpStream.DecodeByteArray(); if (startingBytes.Length == 32) { message.StartBlockHash = new Keccak(startingBytes); } else { message.StartBlockNumber = (long)new UInt256(startingBytes, true); } message.MaxHeaders = rlpStream.DecodeInt(); message.Skip = rlpStream.DecodeInt(); message.Reverse = rlpStream.DecodeByte(); return(message); }
public TransactionInfo Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { rlpStream.ReadSequenceLength(); try { Keccak hash = rlpStream.DecodeKeccak(); UInt256 value = rlpStream.DecodeUInt256(); UInt256 gasPrice = rlpStream.DecodeUInt256(); ulong gasLimit = rlpStream.DecodeUlong(); ulong timestamp = rlpStream.DecodeUlong(); TransactionType type = (TransactionType)rlpStream.DecodeInt(); TransactionState state = (TransactionState)rlpStream.DecodeInt(); return(new TransactionInfo(hash, value, gasPrice, gasLimit, timestamp, type, state)); } catch (Exception e) { throw new RlpException($"{nameof(TransactionInfo)} could not be decoded", e); } }
public HelperTrieProofsMessage Deserialize(RlpStream rlpStream) { HelperTrieProofsMessage message = new HelperTrieProofsMessage(); rlpStream.ReadSequenceLength(); message.RequestId = rlpStream.DecodeLong(); message.BufferValue = rlpStream.DecodeInt(); rlpStream.ReadSequenceLength(); message.ProofNodes = rlpStream.DecodeArray(stream => stream.DecodeByteArray()); message.AuxiliaryData = rlpStream.DecodeArray(stream => stream.DecodeByteArray()); return(message); }
private static GetBlockHeadersMessage Deserialize(RlpStream rlpStream) { GetBlockHeadersMessage message = new GetBlockHeadersMessage(); rlpStream.ReadSequenceLength(); byte[] startingBytes = rlpStream.DecodeByteArray(); if (startingBytes.Length == 32) { message.StartingBlockHash = new Keccak(startingBytes); } else { UInt256.CreateFromBigEndian(out UInt256 result, startingBytes); message.StartingBlockNumber = (long)result; } message.MaxHeaders = rlpStream.DecodeInt(); message.Skip = rlpStream.DecodeInt(); message.Reverse = rlpStream.DecodeByte(); return(message); }
public ReceiptsMessage Deserialize(RlpStream rlpStream) { ReceiptsMessage receiptsMessage = new ReceiptsMessage(); Eth.V63.ReceiptsMessageSerializer ethSerializer = new Eth.V63.ReceiptsMessageSerializer(_specProvider); rlpStream.ReadSequenceLength(); receiptsMessage.RequestId = rlpStream.DecodeLong(); receiptsMessage.BufferValue = rlpStream.DecodeInt(); receiptsMessage.EthMessage = ethSerializer.Deserialize(rlpStream); return(receiptsMessage); }
public AuthEip8Message Deserialize(byte[] data) { RlpStream rlpStream = data.AsRlpStream(); AuthEip8Message authMessage = new AuthEip8Message(); rlpStream.ReadSequenceLength(); byte[] sigAllBytes = rlpStream.DecodeByteArray(); Signature signature = new Signature(sigAllBytes.Slice(0, 64), sigAllBytes[64]); // since Signature class is Ethereum style it expects V as the 64th byte, hence we use RecoveryID constructor authMessage.Signature = signature; authMessage.PublicKey = new PublicKey(rlpStream.DecodeByteArray()); authMessage.Nonce = rlpStream.DecodeByteArray(); int version = rlpStream.DecodeInt(); return authMessage; }
public DepositApproval Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { rlpStream.ReadSequenceLength(); Keccak assetId = rlpStream.DecodeKeccak(); string assetName = rlpStream.DecodeString(); string kyc = rlpStream.DecodeString(); Address consumer = rlpStream.DecodeAddress(); Address provider = rlpStream.DecodeAddress(); ulong timestamp = rlpStream.DecodeUlong(); DepositApprovalState state = (DepositApprovalState)rlpStream.DecodeInt(); return(new DepositApproval(assetId, assetName, kyc, consumer, provider, timestamp, state)); }
public PongMessage Deserialize(byte[] msg) { (PongMessage Message, byte[] Mdc, byte[] Data)results = PrepareForDeserialization <PongMessage>(msg); RlpStream rlp = results.Data.AsRlpStream(); rlp.ReadSequenceLength(); rlp.ReadSequenceLength(); // GetAddress(rlp.DecodeByteArray(), rlp.DecodeInt()); rlp.DecodeByteArray(); rlp.DecodeInt(); // UDP port (we ignore and take it from Netty) rlp.DecodeInt(); // TCP port byte[] token = rlp.DecodeByteArray(); long expirationTime = rlp.DecodeLong(); PongMessage message = results.Message; message.PingMdc = token; message.ExpirationTime = expirationTime; return(message); }
public PingMessage Deserialize(byte[] msg) { (PingMessage Message, byte[] Mdc, byte[] Data)results = PrepareForDeserialization <PingMessage>(msg); RlpStream rlp = results.Data.AsRlpStream(); rlp.ReadSequenceLength(); int version = rlp.DecodeInt(); rlp.ReadSequenceLength(); ReadOnlySpan <byte> sourceAddress = rlp.DecodeByteArraySpan(); // TODO: please note that we decode only one field for port and if the UDP is different from TCP then // our discovery messages will not be routed correctly (the fix will not be part of this commit) rlp.DecodeInt(); // UDP port int tcpPort = rlp.DecodeInt(); // we assume here that UDP and TCP port are same IPEndPoint source = GetAddress(sourceAddress, tcpPort); rlp.ReadSequenceLength(); ReadOnlySpan <byte> destinationAddress = rlp.DecodeByteArraySpan(); IPEndPoint destination = GetAddress(destinationAddress, rlp.DecodeInt()); rlp.DecodeInt(); // UDP port long expireTime = rlp.DecodeLong(); PingMessage message = results.Message; message.SourceAddress = source; message.DestinationAddress = destination; message.Mdc = results.Mdc; message.Version = version; message.ExpirationTime = expireTime; return(message); }
private SortedList <Address, long> DecodeSigners(RlpStream rlpStream) { rlpStream.ReadSequenceLength(); SortedList <Address, long> signers = new SortedList <Address, long>(AddressComparer.Instance); int length = rlpStream.DecodeInt(); for (int i = 0; i < length; i++) { Address signer = rlpStream.DecodeAddress(); long signedAt = (long)rlpStream.DecodeUInt256(); signers.Add(signer, signedAt); } return(signers); }
public FaucetResponse Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { var sequenceLength = rlpStream.ReadSequenceLength(); if (sequenceLength == 0) { return(null); } var status = (FaucetRequestStatus)rlpStream.DecodeInt(); var request = Nethermind.Core.Encoding.Rlp.Decode <FaucetRequestDetails>(rlpStream); return(new FaucetResponse(status, request)); }
public AuthEip8Message Deserialize(byte[] msgBytes) { RlpStream rlpStream = msgBytes.AsRlpStream(); AuthEip8Message authMessage = new(); rlpStream.ReadSequenceLength(); ReadOnlySpan <byte> sigAllBytes = rlpStream.DecodeByteArraySpan(); Signature signature = new(sigAllBytes.Slice(0, 64), sigAllBytes[64]); // since Signature class is Ethereum style it expects V as the 65th byte, hence we use RecoveryID constructor authMessage.Signature = signature; authMessage.PublicKey = new PublicKey(rlpStream.DecodeByteArraySpan()); authMessage.Nonce = rlpStream.DecodeByteArray(); int version = rlpStream.DecodeInt(); return(authMessage); }
public DataDeliveryReceipt Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None) { try { rlpStream.ReadSequenceLength(); StatusCodes statusCode = (StatusCodes)rlpStream.DecodeInt(); uint consumedUnits = rlpStream.DecodeUInt(); uint unpaidUnits = rlpStream.DecodeUInt(); Signature signature = SignatureDecoder.DecodeSignature(rlpStream); return(new DataDeliveryReceipt(statusCode, consumedUnits, unpaidUnits, signature)); } catch (Exception e) { throw new RlpException($"{nameof(DataDeliveryReceiptDecoder)} could not be decoded", e); } }