public static string GetBlockchainPath(this ExpressWalletAccount account)
{
if (account == null)
{
throw new ArgumentNullException(nameof(account));
}
return(Path.Combine(Program.ROOT_PATH, account.ScriptHash));
}
public Task <UInt256> ExecuteAsync(ExpressWalletAccount account, Neo.VM.Script script, decimal additionalGas = 0)
{
if (disposedValue)
{
throw new ObjectDisposedException(nameof(OfflineNode));
}
var devAccount = DevWalletAccount.FromExpressWalletAccount(account);
var devWallet = new DevWallet(string.Empty, devAccount);
var signer = new Signer()
{
Account = devAccount.ScriptHash, Scopes = WitnessScope.CalledByEntry
};
var tx = devWallet.MakeTransaction(script, devAccount.ScriptHash, new[] { signer });
if (additionalGas > 0.0m)
{
tx.SystemFee += (long)additionalGas.ToBigInteger(NativeContract.GAS.Decimals);
}
var context = new ContractParametersContext(tx);
if (devAccount.IsMultiSigContract())
{
var wallets = chain.GetMultiSigWallets(account);
foreach (var wallet in wallets)
{
if (context.Completed)
{
break;
}
wallet.Sign(context);
}
}
else
{
devWallet.Sign(context);
}
if (!context.Completed)
{
throw new Exception();
}
tx.Witnesses = context.GetWitnesses();
return(SubmitTransactionAsync(tx));
}
public static JObject Sign(this ExpressWalletAccount account, byte[] data)
{
var(signature, publicKey) = BlockchainOperations.Sign(account, data);
return(new JObject
{
["signature"] = signature.ToHexString(),
["public-key"] = publicKey.ToHexString(),
["contract"] = new JObject
{
["script"] = account.Contract.Script,
["parameters"] = new JArray(account.Contract.Parameters)
}
});
}
public async Task <UInt256> ExecuteAsync(ExpressWalletAccount account, Script script, decimal additionalGas = 0)
{
var signers = new[] { new Signer {
Scopes = WitnessScope.CalledByEntry, Account = account.AsUInt160()
} };
var factory = new TransactionManagerFactory(rpcClient);
var tm = await factory.MakeTransactionAsync(script, signers).ConfigureAwait(false);
var tx = await tm
.AddGas(additionalGas)
.AddSignatures(chain, account)
.SignAsync()
.ConfigureAwait(false);
return(await SubmitTransactionAsync(tx).ConfigureAwait(false));
}
public static (byte[] signature, byte[] publicKey) Sign(ExpressWalletAccount account, byte[] data)
{
var devAccount = DevWalletAccount.FromExpressWalletAccount(account);
var key = devAccount.GetKey();
if (key == null)
{
throw new InvalidOperationException();
}
var publicKey = key.PublicKey.EncodePoint(false).AsSpan().Slice(1).ToArray();
var signature = Neo.Cryptography.Crypto.Default.Sign(data, key.PrivateKey, publicKey);
return(signature, key.PublicKey.EncodePoint(true));
}
public static JArray Sign(this ExpressWalletAccount account, IEnumerable <ExpressConsensusNode> nodes, JToken?json)
{
if (json == null)
{
throw new ArgumentException(nameof(json));
}
var data = json.Value <string>("hash-data").ToByteArray();
// TODO: better way to identify the genesis account?
if (account.Label == "MultiSigContract")
{
var hashes = json["script-hashes"].Select(t => t.Value <string>());
var signatures = nodes.SelectMany(n => n.Wallet.Sign(hashes, data));
return(new JArray(signatures));
}
else
{
return(new JArray(account.Sign(data)));
}
}
public static Witness GetWitness(Transaction tx, ExpressChain chain, ExpressWalletAccount account)
{
var txHashData = Neo.Network.P2P.Helper.GetHashData(tx);
var devAccount = DevWalletAccount.FromExpressWalletAccount(account);
if (IsMultiSigContract(account))
{
// neo-express only uses multi sig contracts for consensus nodes
var verification = devAccount.Contract.Script;
var signatureCount = devAccount.Contract.ParameterList.Length;
var signatures = chain.ConsensusNodes
.Select(node => DevWalletAccount.FromExpressWalletAccount(node.Wallet.DefaultAccount))
.OrderBy(account => (account.GetKey() ?? throw new Exception("DevWalletAccount missing key")).PublicKey)
.Select(account => Sign(txHashData, account))
.Take(signatureCount)
.ToList();
var invocation = new byte[signatures.Aggregate(0, (a, sig) => a + sig.Length + 1)];
var curPos = 0;
for (int i = 0; i < signatures.Count; i++)
{
invocation[curPos] = 0x40;
signatures[i].AsSpan().CopyTo(invocation.AsSpan().Slice(curPos + 1, signatures[i].Length));
curPos += 1 + signatures[i].Length;
}
return(new Witness()
{
InvocationScript = invocation,
VerificationScript = verification,
});
}
else
{
public ExpressRpcServer(IExpressReadOnlyStore store, ExpressWalletAccount multiSigAccount)
{
this.store = store;
this.multiSigAccount = multiSigAccount;
cacheId = DateTimeOffset.Now.Ticks.ToString();
}
public static TransactionManager AddSignatures(this TransactionManager tm, ExpressChain chain, ExpressWalletAccount account)
{
if (account.IsMultiSigContract())
{
var signers = chain.GetMultiSigAccounts(account);
var publicKeys = signers.Select(s => s.GetKey() !.PublicKey).ToArray();
var sigCount = account.Contract.Parameters.Count;
foreach (var signer in signers.Take(sigCount))
{
var keyPair = signer.GetKey() ?? throw new Exception();
tm = tm.AddMultiSig(keyPair, sigCount, publicKeys);
}
return(tm);
}
else
{
return(tm.AddSignature(account.GetKey() !));
}
}
private static bool IsMultiSigContract(ExpressWalletAccount account) => Neo.SmartContract.Helper.IsMultiSigContract(account.Contract.Script.ToByteArray());
public static IEnumerable <DevWalletAccount> GetMultiSigAccounts(this ExpressChain chain, ExpressWalletAccount account) => chain.ConsensusNodes .Select(n => n.Wallet) .Concat(chain.Wallets) .Select(w => w.Accounts.Find(a => a.ScriptHash == account.ScriptHash)) .Where(a => a != null) .Select(DevWalletAccount.FromExpressWalletAccount !);
public static UInt160 AsUInt160(this ExpressWalletAccount account) => account.ScriptHash.ToScriptHash();
public static KeyPair GetKey(this ExpressWalletAccount account) => new KeyPair(account.PrivateKey.HexToBytes());
