feat(account): add IAccount, ISigner, and IAsyncSigner interfaces

These are used to start implementing accounts for all types of signing.

fix #82

Author: jasonboukheir

Runtime/CareBoo.AlgoSdk/Account/Account.cs

@@ -1,18 +1,105 @@
+using System;
+using Cysharp.Threading.Tasks;
+using Unity.Collections;
+
 namespace AlgoSdk
 {
+    public interface IAccount
+    {
+        /// <summary>
+        /// Address of this account
+        /// </summary>
+        Address Address { get; }
+    }
+
     /// <summary>
-    /// Contains utility functions for generating new accounts (private keys).
+    /// A local, in-memory account.
     /// </summary>
-    public static class Account
+    public readonly struct Account
+        : IAccount
+        , ISigner
+        , IAsyncSigner
     {
+        readonly PrivateKey privateKey;
+
+        readonly Address address;
+
+        readonly bool isRekeyed;
+
+        public Address Address => address;
+
+        public bool IsRekeyed => isRekeyed;
+
+        /// <summary>
+        /// Instantiate an in-memory account.
+        /// </summary>
+        /// <param name="privateKey">The private key of the account.</param>
+        public Account(PrivateKey privateKey)
+        {
+            this.privateKey = privateKey;
+            this.address = privateKey.ToAddress();
+            this.isRekeyed = false;
+        }
+
+        /// <summary>
+        /// Instantiate an in-memory account that is rekeyed.
+        /// </summary>
+        /// <param name="privateKey">The private key of the account.</param>
+        /// <param name="address">The address of this account.</param>
+        public Account(PrivateKey privateKey, Address address)
+        {
+            this.privateKey = privateKey;
+            this.address = address;
+            this.isRekeyed = !address.Equals(privateKey.ToAddress());
+        }
+
         /// <summary>
-        /// Generate a fresh account
+        /// Generate a random, fresh account
         /// </summary>
-        /// <returns>A private key, address tuple.</returns>
-        public static (PrivateKey, Address) GenerateAccount()
+        public static Account GenerateAccount()
         {
             var privateKey = AlgoSdk.Crypto.Random.Bytes<PrivateKey>();
-            return (privateKey, privateKey.ToPublicKey());
+            return new Account(privateKey);
+        }
+
+        public void Deconstruct(out PrivateKey privateKey, out Address address)
+        {
+            privateKey = this.privateKey;
+            address = this.address;
+        }
+
+        public UniTask<SignedTxn<T>> SignTxnAsync<T>(T txn) where T : ITransaction, IEquatable<T>
+        {
+            return UniTask.FromResult(SignTxn(txn));
+        }
+
+        public UniTask<SignedTxn<T>[]> SignTxnsAsync<T>(T[] txns) where T : ITransaction, IEquatable<T>
+        {
+            return UniTask.FromResult(SignTxns(txns));
+        }
+
+        public SignedTxn<T> SignTxn<T>(T txn) where T : ITransaction, IEquatable<T>
+        {
+            using var kp = privateKey.ToKeyPair();
+            using var msg = txn.ToSignatureMessage(Allocator.Temp);
+            var sig = kp.SecretKey.Sign(msg);
+            return new SignedTxn<T> { Txn = txn, Sig = sig };
+        }
+
+        public SignedTxn<T>[] SignTxns<T>(T[] txns) where T : ITransaction, IEquatable<T>
+        {
+            var groupId = TransactionGroup.Of(txns).GetId();
+            var signedTxns = new SignedTxn<T>[txns.Length];
+            for (var i = 0; i < txns.Length; i++)
+            {
+                var txn = txns[i];
+                txn.Group = groupId;
+                signedTxns[i] = txn.Sender.Equals(Address)
+                    ? SignTxn(txn)
+                    : new SignedTxn<T> { Txn = txn }
+                    ;
+            }
+            return signedTxns;
         }
     }
 }

Runtime/CareBoo.AlgoSdk/Account/Logic.cs

@@ -16,7 +16,7 @@ public static class Logic
         /// </summary>
         /// <param name="program">The stateful or stateless program to get the address of.</param>
         /// <returns>An <see cref="Address"/> for a program.</returns>
-        public static Address GetAddress(byte[] program)
+        public static Address GetAddress(CompiledTeal program)
         {
             using var bytes = GetSignBytes(program, Allocator.Temp);
             return Sha512.Hash256Truncated(bytes);
@@ -28,15 +28,15 @@ public static Address GetAddress(byte[] program)
         /// <param name="program">The program that will be signed.</param>
         /// <param name="allocator">Defines the memory lifetime used for <see cref="NativeByteArray"/>, which must be disposed.</param>
         /// <returns>A <see cref="NativeByteArray"/>. The caller must manage its lifetime.</returns>
-        public static NativeByteArray GetSignBytes(byte[] program, Allocator allocator)
+        public static NativeByteArray GetSignBytes(CompiledTeal program, Allocator allocator)
         {
-            var bytes = new NativeByteArray(SigningPrefix.Length + program.Length, allocator);
+            var bytes = new NativeByteArray(SigningPrefix.Length + program.Bytes.Length, allocator);
             try
             {
                 for (var i = 0; i < SigningPrefix.Length; i++)
                     bytes[i] = SigningPrefix[i];
                 for (var i = SigningPrefix.Length; i < bytes.Length; i++)
-                    bytes[i] = program[i - SigningPrefix.Length];
+                    bytes[i] = program.Bytes[i - SigningPrefix.Length];
             }
             finally
             {
@@ -51,7 +51,7 @@ public static NativeByteArray GetSignBytes(byte[] program, Allocator allocator)
         /// <param name="program">Program to sign</param>
         /// <param name="secretKey">Key to sign this program with.</param>
         /// <returns><see cref="Sig"/></returns>
-        public static Sig Sign(byte[] program, SecretKeyHandle secretKey)
+        public static Sig Sign(CompiledTeal program, SecretKeyHandle secretKey)
         {
             using var programSignBytes = Logic.GetSignBytes(program, Allocator.Temp);
             return secretKey.Sign(programSignBytes);
@@ -64,7 +64,7 @@ public static Sig Sign(byte[] program, SecretKeyHandle secretKey)
         /// <param name="msig">A <see cref="Multisig"/> that contains the <see cref="PublicKey"/> matching <paramref name="privateKey"/>.</param>
         /// <param name="privateKey">The private key to sign with. Its corresponding <see cref="PublicKey"/> must be inside of <paramref name="msig"/>.</param>
         /// <returns>A tuple of the <see cref="Sig"/> from signing the program and its index in the <paramref name="msig"/></returns>
-        public static (Sig, int) Sign(byte[] program, Multisig msig, PrivateKey privateKey)
+        public static (Sig, int) Sign(CompiledTeal program, Multisig msig, PrivateKey privateKey)
         {
             if (msig.Subsigs == null)
                 throw new ArgumentException("msig has null Sub signatures", nameof(msig));

Runtime/CareBoo.AlgoSdk/Account/Signer.cs

@@ -0,0 +1,43 @@
+using System;
+using Cysharp.Threading.Tasks;
+
+namespace AlgoSdk
+{
+    public interface ISigner
+    {
+        /// <summary>
+        /// Sign a single transaction.
+        /// </summary>
+        /// <param name="txn">The transaction to sign.</param>
+        /// <typeparam name="T">The type of the transaction.</typeparam>
+        /// <returns>Transaction with signature if it was signed.</returns>
+        SignedTxn<T> SignTxn<T>(T txn) where T : ITransaction, IEquatable<T>;
+
+        /// <summary>
+        /// Sign a group of transactions.
+        /// </summary>
+        /// <param name="txns">The transactions to sign.</param>
+        /// <typeparam name="T">The type of the transactions.</typeparam>
+        /// <returns>An array of transactions with signatures. If the transaction at a given index was not signed, that signed transaction will have no signature.</returns>
+        SignedTxn<T>[] SignTxns<T>(T[] txns) where T : ITransaction, IEquatable<T>;
+    }
+
+    public interface IAsyncSigner
+    {
+        /// <summary>
+        /// Sign a single transaction.
+        /// </summary>
+        /// <param name="txn">The transaction to sign.</param>
+        /// <typeparam name="T">The type of the transaction.</typeparam>
+        /// <returns>Transaction with signature if it was signed.</returns>
+        UniTask<SignedTxn<T>> SignTxnAsync<T>(T txn) where T : ITransaction, IEquatable<T>;
+
+        /// <summary>
+        /// Sign a group of transactions.
+        /// </summary>
+        /// <param name="txns">The transactions to sign.</param>
+        /// <typeparam name="T">The type of the transactions.</typeparam>
+        /// <returns>An array of transactions with signatures. If the transaction at a given index was not signed, that signed transaction will have no signature.</returns>
+        UniTask<SignedTxn<T>[]> SignTxnsAsync<T>(T[] txns) where T : ITransaction, IEquatable<T>;
+    }
+}

Runtime/CareBoo.AlgoSdk/Account/Signer.cs.meta

@@ -11,27 +11,27 @@ public interface ITransaction
         /// <summary>
         /// Paid by the sender to the FeeSink to prevent denial-of-service. The minimum fee on Algorand is currently 1000 microAlgos.
         /// </summary>
-        ulong Fee { get; }
+        ulong Fee { get; set; }
 
         /// <summary>
         /// The first round for when the transaction is valid. If the transaction is sent prior to this round it will be rejected by the network.
         /// </summary>
-        ulong FirstValidRound { get; }
+        ulong FirstValidRound { get; set; }
 
         /// <summary>
         /// The hash of the genesis block of the network for which the transaction is valid.
         /// </summary>
-        GenesisHash GenesisHash { get; }
+        GenesisHash GenesisHash { get; set; }
 
         /// <summary>
         /// The ending round for which the transaction is valid. After this round, the transaction will be rejected by the network.
         /// </summary>
-        ulong LastValidRound { get; }
+        ulong LastValidRound { get; set; }
 
         /// <summary>
         /// The address of the account that pays the fee and amount.
         /// </summary>
-        Address Sender { get; }
+        Address Sender { get; set; }
 
         /// <summary>
         /// Specifies the type of transaction. This value is automatically generated using any of the developer tools.
@@ -41,27 +41,27 @@ public interface ITransaction
         /// <summary>
         /// The human-readable string that identifies the network for the transaction. The genesis ID is found in the genesis block.
         /// </summary>
-        FixedString32Bytes GenesisId { get; }
+        FixedString32Bytes GenesisId { get; set; }
 
         /// <summary>
         /// The group specifies that the transaction is part of a group and, if so, specifies the hash of the transaction group. See <see cref="Transaction.GetGroupId"/>.
         /// </summary>
-        Sha512_256_Hash Group { get; }
+        Sha512_256_Hash Group { get; set; }
 
         /// <summary>
         /// A lease enforces mutual exclusion of transactions. If this field is nonzero, then once the transaction is confirmed, it acquires the lease identified by the (Sender, Lease) pair of the transaction until the LastValid round passes. While this transaction possesses the lease, no other transaction specifying this lease can be confirmed. A lease is often used in the context of Algorand Smart Contracts to prevent replay attacks.
         /// </summary>
-        Sha512_256_Hash Lease { get; }
+        Sha512_256_Hash Lease { get; set; }
 
         /// <summary>
         /// Any data up to 1000 bytes.
         /// </summary>
-        byte[] Note { get; }
+        byte[] Note { get; set; }
 
         /// <summary>
         /// Specifies the authorized address. This address will be used to authorize all future transactions.
         /// </summary>
-        Address RekeyTo { get; }
+        Address RekeyTo { get; set; }
 
         /// <summary>
         /// Copy this transactions fields to a <see cref="Transaction"/> which contains all possible transaction fields.

Runtime/CareBoo.AlgoSdk/Transaction/ITransaction.cs

@@ -25,6 +25,27 @@ public partial struct TransactionGroup
         /// </summary>
         public static readonly byte[] IdPrefix = Encoding.UTF8.GetBytes("TG");
 
+        /// <summary>
+        /// Generate a TransactionGroup with the given transactions that can be used to generate a GroupId.
+        /// </summary>
+        /// <param name="txns">The transactions to use.</param>
+        /// <typeparam name="T">The type of the transactions.</typeparam>
+        public static TransactionGroup Of<T>(params T[] txns) where T : ITransaction, IEquatable<T>
+        {
+            if (txns == null || txns.Length == 0)
+                throw new ArgumentException("Cannot get the group id of 0 transactions", nameof(txns));
+            if (txns.Length > TransactionGroup.MaxSize)
+                throw new ArgumentException($"Cannot get the group id of a group of more than {TransactionGroup.MaxSize} transactions", nameof(txns));
+
+            var txnIds = new TransactionId[txns.Length];
+            for (var i = 0; i < txns.Length; i++)
+            {
+                txns[i].Group = default;
+                txnIds[i] = txns[i].GetId();
+            }
+            return new TransactionGroup { Txns = txnIds };
+        }
+
         /// <summary>
         /// The list of transaction ids belonging to this group.
         /// </summary>