public void Init()
{
// Deploy native contracts
var block = new Network.P2P.Payloads.Block()
{
Index = 0,
ConsensusData = new Network.P2P.Payloads.ConsensusData(),
Transactions = new Network.P2P.Payloads.Transaction[0],
Witness = new Network.P2P.Payloads.Witness()
{
InvocationScript = new byte[0],
VerificationScript = Contract.CreateSignatureRedeemScript(ECPoint.FromBytes(pubKey, ECCurve.Secp256k1))
},
NextConsensus = UInt160.Zero,
MerkleRoot = UInt256.Zero,
PrevHash = UInt256.Zero
};
_engine = new TestEngine(TriggerType.Application, block);
((TestSnapshot)_engine.Snapshot).SetPersistingBlock(block);
_engine.Snapshot.DeployNativeContracts();
_engine.Reset();
_engine.AddEntryScript("./TestClasses/Contract_Native.cs");
}
public NeoKey(byte[] privateKey)
{
if (privateKey.Length != 32 && privateKey.Length != 96 && privateKey.Length != 104)
{
throw new ArgumentException();
}
this.PrivateKey = new byte[32];
Buffer.BlockCopy(privateKey, privateKey.Length - 32, PrivateKey, 0, 32);
ECPoint pKey;
if (privateKey.Length == 32)
{
pKey = ECCurve.Secp256r1.G * privateKey;
}
else
{
pKey = ECPoint.FromBytes(privateKey, ECCurve.Secp256r1);
}
var bytes = pKey.EncodePoint(true).ToArray();
this.CompressedPublicKey = bytes;
this.PublicKeyHash = CryptoUtils.ToScriptHash(bytes);
this.signatureScript = CreateSignatureScript(bytes);
signatureHash = CryptoUtils.ToScriptHash(signatureScript);
this.PublicKey = pKey.EncodePoint(false).Skip(1).ToArray();
this.address = CryptoUtils.ToAddress(signatureHash);
this.WIF = GetWIF();
}
public void Init()
{
// Deploy native contracts
var block = new Network.P2P.Payloads.Block()
{
Index = 0,
ConsensusData = new Network.P2P.Payloads.ConsensusData(),
Transactions = new Network.P2P.Payloads.Transaction[0],
Witness = new Network.P2P.Payloads.Witness()
{
InvocationScript = new byte[0],
VerificationScript = Contract.CreateSignatureRedeemScript(ECPoint.FromBytes(pubKey, ECCurve.Secp256k1))
},
NextConsensus = UInt160.Zero,
MerkleRoot = UInt256.Zero,
PrevHash = UInt256.Zero
};
_engine = new TestEngine(TriggerType.Application, block);
((TestSnapshot)_engine.Snapshot).SetPersistingBlock(block);
using (var script = new ScriptBuilder())
{
script.EmitSysCall(TestEngine.Native_Deploy);
_engine.LoadScript(script.ToArray());
Assert.AreEqual(VMState.HALT, _engine.Execute());
}
_engine.Reset();
_engine.AddEntryScript("./TestClasses/Contract_Native.cs");
}
public bool Sign(SignatureContext context)
{
bool fSuccess = false;
foreach (UInt160 scriptHash in context.ScriptHashes)
{
Contract contract = GetContract(scriptHash);
if (contract == null)
{
continue;
}
Account account = GetAccountByScriptHash(scriptHash);
if (account == null)
{
continue;
}
byte[] signature;
using (account.Decrypt())
{
signature = context.Signable.Sign(account.PrivateKey, account.PublicKey);
}
fSuccess |= context.Add(contract.RedeemScript, ECPoint.FromBytes(account.PublicKey, ECCurve.Secp256r1), signature);
}
return(fSuccess);
}
private bool VerifyKeyAndSignature(Signature signature, out ECPoint pubKey)
{
pubKey = null;
// 0. only support ecdsa and secp256k1 for now, hashing is sha256
if (signature.SignatureType != SignatureType.Ecdsa || signature.PublicKey.CurveType != CurveType.Secp256r1)
{
return(false);
}
// 1. check public key bytes
try
{
pubKey = ECPoint.FromBytes(signature.PublicKey.Bytes, ECCurve.Secp256r1);
}
catch (Exception)
{
return(false);
}
// 2. check if public key matches address
if (("21" + pubKey.EncodePoint(true).ToHexString() + "ac").HexToBytes().ToScriptHash().ToAddress() != signature.SigningPayload.Address)
{
return(false);
}
// 3. check if public key and signature matches
return(Crypto.Default.VerifySignature(signature.SigningPayload.Bytes, signature.Bytes, pubKey.EncodePoint(false)));
}
/// <summary>
/// Derive returns the network-specific address associated with a public key.
/// Blockchains that require an on-chain action to create an account should not implement this method.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public JObject ConstructionDerive(ConstructionDeriveRequest request)
{
if (request.NetworkIdentifier?.Blockchain?.ToLower() != "neo n3")
{
return(Error.NETWORK_IDENTIFIER_INVALID.ToJson());
}
if (request.NetworkIdentifier?.Network?.ToLower() != network)
{
return(Error.NETWORK_IDENTIFIER_INVALID.ToJson());
}
if (request.PublicKey.CurveType != CurveType.Secp256r1)
{
return(Error.CURVE_NOT_SUPPORTED.ToJson());
}
ECPoint pubKey;
try
{
pubKey = ECPoint.FromBytes(request.PublicKey.HexBytes.HexToBytes(), ECCurve.Secp256r1);
}
catch (Exception)
{
return(Error.INVALID_PUBLIC_KEY.ToJson());
}
string address = Contract.CreateSignatureRedeemScript(pubKey).ToScriptHash().ToAddress(system.Settings.AddressVersion);
ConstructionDeriveResponse response = new ConstructionDeriveResponse(new AccountIdentifier(address));
return(response.ToJson());
}
string IAddressGenerator.GenerateAddress(byte[] pubKeyBytes)
{
var pubKey = ECPoint.FromBytes(pubKeyBytes, ECCurve.Secp256r1);
UInt160 scriptHash = Contract.CreateSignatureContract(pubKey).ScriptHash;
string address = scriptHash.ToAddress(ProtocolSettings.Default.AddressVersion);
return(address);
}
public Account(byte[] privateKey)
{
if (privateKey.Length != 32 && privateKey.Length != 96 && privateKey.Length != 104)
{
throw new ArgumentException();
}
this.PrivateKey = new byte[32];
Buffer.BlockCopy(privateKey, privateKey.Length - 32, PrivateKey, 0, 32);
if (privateKey.Length == 32)
{
this.PublicKey = ECCurve.Secp256r1.G * privateKey;
}
else
{
this.PublicKey = ECPoint.FromBytes(privateKey, ECCurve.Secp256r1);
}
this.PublicKeyHash = PublicKey.EncodePoint(true).ToScriptHash();
ProtectedMemory.Protect(PrivateKey, MemoryProtectionScope.SameProcess);
}
public KeyPair(byte[] privateKey)
{
if (privateKey.Length != 32 && privateKey.Length != 96 && privateKey.Length != 104)
{
throw new ArgumentException();
}
PrivateKey = new byte[32];
Buffer.BlockCopy(privateKey, privateKey.Length - 32, PrivateKey, 0, 32);
if (privateKey.Length == 32)
{
PublicKey = ECCurve.Secp256r1.G * privateKey;
}
else
{
PublicKey = ECPoint.FromBytes(privateKey, ECCurve.Secp256r1);
}
#if NET47
ProtectedMemory.Protect(PrivateKey, MemoryProtectionScope.SameProcess);
#endif
}
/// <summary>
/// Derive returns the network-specific address associated with a public key.
/// Blockchains that require an on-chain action to create an account should not implement this method.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public JObject ConstructionDerive(ConstructionDeriveRequest request)
{
if (request.PublicKey.CurveType != CurveType.Secp256r1)
{
return(Error.CURVE_NOT_SUPPORTED.ToJson());
}
ECPoint pubKey;
try
{
pubKey = ECPoint.FromBytes(request.PublicKey.Bytes, ECCurve.Secp256r1);
}
catch (Exception)
{
return(Error.INVALID_PUBLIC_KEY.ToJson());
}
string address = ("21" + pubKey.EncodePoint(true).ToHexString() + "ac").HexToBytes().ToScriptHash().ToAddress();
ConstructionDeriveResponse response = new ConstructionDeriveResponse(address);
return(response.ToJson());
}
public void Init()
{
// Deploy native contracts
var block = new Block()
{
Header = new Header()
{
Index = 0,
Witness = new Witness()
{
InvocationScript = System.Array.Empty <byte>(),
VerificationScript = Contract.CreateSignatureRedeemScript(ECPoint.FromBytes(pubKey, ECCurve.Secp256k1))
},
NextConsensus = UInt160.Zero,
MerkleRoot = UInt256.Zero,
PrevHash = UInt256.Zero
},
Transactions = System.Array.Empty <Transaction>(),
};
_engine = new TestEngine(TriggerType.Application, block, new TestDataCache(block));
_engine.Reset();
_engine.AddEntryScript("./TestClasses/Contract_Native.cs");
}
/// <summary>
/// Public Key => (UInt160)address hash
/// </summary>
/// <param name="publicKeyHex"></param>
/// <returns></returns>
public static UInt160 ToUInt160FromPublicKey(this string publicKeyHex)
{
var point = ECPoint.FromBytes(publicKeyHex.HexToBytes(), ECCurve.Secp256r1);
return(point.ToUInt160FromPublicKey());
}
private MinerWallet(byte[] key_exported)
{
this.key_exported = key_exported;
this.PublicKey = ECPoint.FromBytes(key_exported, ECCurve.Secp256r1);
ProtectedMemory.Protect(key_exported, MemoryProtectionScope.SameProcess);
}