如何用C#编写跨平台的Algorand钱包

string ALGOD_API_ADDR = "ALGOD_API_ADDR";  //在此处添加ALGOD TESTNET API地址
string ALGOD_API_TOKEN = "ALGOD_API_TOKEN";    //在此处添加ALGOD API KEY
AlgodApi algodApiInstance = new AlgodApi(ALGOD_API_ADDR, ALGOD_API_TOKEN);

try
{
    Supply supply = algodApiInstance.GetSupply();
    Console.WriteLine("Total Algorand Supply: " + supply.TotalMoney);
    Console.WriteLine("Online Algorand Supply: " + supply.OnlineMoney);
}catch (ApiException e)
{
    Console.WriteLine("Exception when calling algod#getSupply: " + e.Message);
}

// 向DEST_ADDR转账0.1algo
// 注意转账都是Micro Algos为单位的，1 Algo = 1e6 Micro Algos
// 两者之间的转换可以用Utils.AlgosToMicroalgos及Utils.MicroalgosToAlgos
ulong? amount = 100000;
ulong? lastRound = firstRound + 1000; // 1000 is the max tx window            
string SRC_ACCOUNT = "typical permit hurdle hat song detail cattle merge oxygen crowd arctic cargo smooth fly rice vacuum lounge yard frown predict west wife latin absent cup";
Account src = new Account(SRC_ACCOUNT);
Console.WriteLine("My account address is:" + src.Address.ToString());
string DEST_ADDR = "KV2XGKMXGYJ6PWYQA5374BYIQBL3ONRMSIARPCFCJEAMAHQEVYPB7PL3KU";
// Transaction中包含一次交易中几乎所有的信息
// 需要注意的是Transaction需要经过签名才能发送到区区块链
Transaction tx = new Transaction(src.Address, new Address(DEST_ADDR), amount, firstRound, lastRound, genesisID, genesisHash);
//sign the transaction before send it to the blockchain
SignedTransaction signedTx = src.SignTransactionWithFeePerByte(tx, (ulong)feePerByte);
Console.WriteLine("Signed transaction with txid: " + signedTx.transactionID);// send the transaction to the network
try
{
//交易信息编码
var encodedMsg = Algorand.Encoder.EncodeToMsgPack(signedTx);
//发送交易
    TransactionID id = algodApiInstance.RawTransaction(encodedMsg);
    Console.WriteLine("Successfully sent tx with id: " + id.TxId);
}catch (ApiException e)
{
    // This is generally expected, but should give us an informative error message.
    Console.WriteLine("Exception when calling algod#rawTransaction: " + e.Message);
}

    // ASA转账
    // 激活后account3就可以接收ASA了
    // 现在我们从acctout1向account3转账
    // First we update standard Transaction parameters
    // To account for changes in the state of the blockchain
    transParams = algodApiInstance.TransactionParams();
    // Next we set asset xfer specific parameters
    // We set the assetCloseTo to null so we do not close the asset out
    ulong assetAmount = 10;
    tx = Utils.GetTransferAssetTransaction(acct1.Address, acct3.Address, assetID, assetAmount, transParams, null, "transfer message");
    // The transaction must be signed by the sender account
    // We are reusing the signedTx variable from the first transaction in the example    
    signedTx = acct1.SignTransaction(tx);
    // send the transaction to the network and
    // wait for the transaction to be confirmed
    try
    {
        TransactionID id = Utils.SubmitTransaction(algodApiInstance, signedTx);
        Console.WriteLine("Transaction ID: " + id.TxId);
        Console.WriteLine(Utils.WaitTransactionToComplete(algodApiInstance, id.TxId));
        // We can now list the account information for acct3 
        // and see that it now has 5 of the new asset
        act = algodApiInstance.AccountInformation(acct3.Address.ToString());
        Console.WriteLine(act.GetHolding(assetID).Amount);
    }
    catch (Exception e)
    {
        //e.printStackTrace();
        Console.WriteLine(e.Message);
        return;
    }

<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
        x:Class="algo_wallet_tutorial.MainWindow"
        Title="algo_wallet_tutorial">
  <Window.Styles>
    <Style Selector="TextBlock.h1">
      <Setter Property="FontSize" Value="24"/>
      <Setter Property="FontWeight" Value="Bold"/>
      <Setter Property="HorizontalAlignment" Value="Center"/>
    </Style>
    <Style Selector="Button.btn">
      <Setter Property="Margin" Value="50 0"/>
      <Setter Property="Width" Value="150"/>
    </Style>
  </Window.Styles>
  <StackPanel Name="sp_enterPassword" Orientation="Vertical"
              HorizontalAlignment="Center">
    <TextBlock Classes="h1" Margin="0 20 0 0">Enter The Password</TextBlock>
    <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" VerticalAlignment="Center" Margin="0 40 0 0">
      <ComboBox Width="100" Name="cb_accountList" SelectedIndex="0">
      </ComboBox>
      <TextBox Width="400" Name="tb_enterPassword" PasswordChar="*" FontWeight="16"></TextBox>
    </StackPanel>
    <StackPanel Orientation="Horizontal" Margin="0 40 0 0">
      <Button Classes="btn">Close</Button>
      <Button Classes="btn">OK</Button>
    </StackPanel>
  </StackPanel>
</Window>

using Avalonia;
using Avalonia.Controls;
using Avalonia.Markup.Xaml;

namespace algo_wallet_tutorial
{
    public class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
#if DEBUG
            this.AttachDevTools();
#endif
            this.FindControl<Button>("btn_enterpsd_ok").Click += BtnEnterpsdClicked;
        }

        private void InitializeComponent()
        {
            AvaloniaXamlLoader.Load(this);            
        }

        private void BtnEnterpsdClicked(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            var btn = sender as Button;
            btn.Content = "Clicked";
        }
    }
}

using System;
using System.Text;
using System.Collections.Generic;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Modes;
using Org.BouncyCastle.Crypto.Parameters;


namespace privatkey_scrypt
{
    public class CryptoUtils
    {
        private const int KEY_BIT_SIZE = 256;
        private const int MAC_BIT_SIZE = 128;
        public static byte[] DecryptAesGcm(byte[] key, byte[] nonce, byte[] cipherText, byte[] tag)
        {
            List<byte> msgList = new List<byte>(cipherText);
            msgList.AddRange(tag);
            byte[] message = msgList.ToArray();
            if (key == null || key.Length != KEY_BIT_SIZE / 8)
                throw new ArgumentException(String.Format("Key needs to be {0} bit!", KEY_BIT_SIZE), "key");
            if (message == null || message.Length == 0)
                throw new ArgumentException("Message required!", "message");

            var cipher = new GcmBlockCipher(new AesEngine());
            var parameters = new AeadParameters(new KeyParameter(key), MAC_BIT_SIZE, nonce);
            cipher.Init(false, parameters);
            var plainText = new byte[cipher.GetOutputSize(message.Length)];
            try
            {
                var len = cipher.ProcessBytes(message, 0, message.Length, plainText, 0);
                cipher.DoFinal(plainText, len);
            }
            catch (InvalidCipherTextException)
            {
                return null;
            }
            return plainText;
        }
        public static byte[] EncryptAesGcm(byte[] key, byte[] nonce, byte[] plaintext)
        {
            if (key == null || key.Length != KEY_BIT_SIZE / 8)
                throw new ArgumentException(String.Format("Key needs to be {0} bit!", KEY_BIT_SIZE), "key");
            var cipher = new GcmBlockCipher(new AesEngine());
            var parameters = new AeadParameters(new KeyParameter(key), MAC_BIT_SIZE, nonce);
            cipher.Init(true, parameters);
            var cipherText = new byte[cipher.GetOutputSize(plaintext.Length)];
            var len = cipher.ProcessBytes(plaintext, 0, plaintext.Length, cipherText, 0);
            cipher.DoFinal(cipherText, len);
            return cipherText;
        }
        public static byte[] GetCipherTextFromAesGcmResult(byte[] result)
        {
            if (result.Length == 16 + 32)
                return result.AsSpan().Slice(0, 32).ToArray();
            else
                return null;
        }
        public static byte[] GetTagFromAesGcmResult(byte[] result)
        {
            if (result.Length == 16 + 32)
                return result.AsSpan().Slice(32, 16).ToArray();
            else
                return null;
        }
        /// <summary>
        /// Generate a random 16 bits salt
        /// </summary>
        /// <returns>16 bits salt</returns>
        public static byte[] GenerateRandomSalt()
        {
            var salt = new byte[16];
            new SecureRandom().NextBytes(salt);
            return salt;
        }
        /// <summary>
        /// Use Scrypt to generate 48 bytes hash.
        /// Scrypt is used instead of Bscrypt because Bscrypt cannot work when importing the wallet
        /// </summary>
        /// <param name="salt">salt</param>
        /// <param name="pwd">password</param>
        /// <returns>the generated 48 bytes hash</returns>
        public static byte[] GenerateHash(byte[] salt, string pwd)
        {
            if (salt.Length != 16)
                return null;
            var password = Encoding.UTF8.GetBytes(pwd);
            const int SCryptN = 262144;
            return SCrypt.Generate(password, salt, SCryptN, 8, 1, 48);
        }
        /// <summary>
        /// Use the first 16 bytes to check the entered password is correct
        /// </summary>
        /// <param name="key">a 48 bytes, usually generated by Scrypt</param>
        /// <returns>the first 16 bytes</returns>
        public static byte[] GetCheckSalt(byte[] key)
        {
            if (key.Length != 48)
                return null;
            var key_list = new List<byte>(key);
            key_list.RemoveRange(16, 32);
            return key_list.ToArray();
        }
        /// <summary>
        /// Use the last 32 bytes as the Master-Key of algorand account
        /// </summary>
        /// <param name="key">a 48 bytes, usually generated by Scrypt</param>
        /// <returns>the last 32 bytes</returns>
        public static byte[] GetMasterKey(byte[] key)
        {
            if (key.Length != 48)
                return null;
            var key_list = new List<byte>(key);
            key_list.RemoveRange(0, 16);
            return key_list.ToArray();
        }
    }
}

using System;
using System.Linq;
using System.Text;

namespace privatkey_scrypt
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
        /// <summary>
        /// 加密过程
        /// </summary>
        /// <param name="accountPassword">密码</param>
        /// <param name="masterKey">私钥：32位</param>
        static void scrypt(string accountPassword, byte[] masterKey)
        {
            var salt = CryptoUtils.GenerateRandomSalt(); //生成16位的随机salt，需要存储于本地
            var scryptedKey = CryptoUtils.GenerateHash(salt, accountPassword); //生成48位二进制
            var checkSalt = CryptoUtils.GetCheckSalt(scryptedKey); //前16位用于存储本地，后续用于较验密码
            //GetMasterKey只是获取了48位二进制的后32位，此32位并不是MasterKey，是用于AESGCM加密的Key
            //由于历史原因起名为GetMasterKey，为了与Algo-Wallet一致此处也用此名字
            var aesgcmKey = CryptoUtils.GetMasterKey(scryptedKey);
            //如果需要秘钥文件可以在不同的程序间迁移，则用固定值
            //如果需要秘钥文件在不同的程序间不可迁移，请使用
            //Org.BouncyCastle.Security.SecureRandom类生成随机nonce
            var nonce = Encoding.UTF8.GetBytes("algo--wallet");
            // aesgcmCipherBytes为48位二进制，存储本地
            var aesgcmCipherBytes = CryptoUtils.EncryptAesGcm(aesgcmKey, nonce, masterKey);
        }
        /// <summary>
        /// 解密过程
        /// </summary>
        /// <param name="accountPassword">密码</param>
        /// <param name="salt">存储于本地的16位salt</param>
        /// <param name="checkSalt">存储于本地的16位二进制</param>
        /// <param name="aesgcmCipherBytes">存储于本地的48位二进制</param>
        static void descrypt(string accountPassword, byte[] salt, byte[] checkSalt, byte[] aesgcmCipherBytes)
        {
            var scryptedKey = CryptoUtils.GenerateHash(salt, accountPassword); //生成48位二进制
            var calcedCheckSalt = CryptoUtils.GetCheckSalt(scryptedKey); //前16位用于存储本地，后续用于较验密码
            if(!Enumerable.SequenceEqual(checkSalt, calcedCheckSalt)) return; //密码错误
            var nonce = Encoding.UTF8.GetBytes("algo--wallet");
            //解密得到masterKey
            var masterKey = CryptoUtils.DecryptAesGcm(CryptoUtils.GetMasterKey(scryptedKey), nonce, 
                CryptoUtils.GetCipherTextFromAesGcmResult(aesgcmCipherBytes), 
                CryptoUtils.GetTagFromAesGcmResult(aesgcmCipherBytes));
        }
    }
}