[Native - Smart Wallet] Session keys, admin adding and force deploy fix

Author: 0xFirekeeper

Assets/Thirdweb/Core/Contract Definitions/Account/AccountService.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Numerics;
+using Nethereum.Hex.HexTypes;
+using Nethereum.ABI.FunctionEncoding.Attributes;
+
+namespace Thirdweb.Contracts.Account.ContractDefinition
+{
+    public partial class SignerPermissionRequest : SignerPermissionRequestBase { }
+
+    public class SignerPermissionRequestBase
+    {
+        [Parameter("address", "signer", 1)]
+        public virtual string Signer { get; set; }
+
+        [Parameter("uint8", "isAdmin", 2)]
+        public virtual byte IsAdmin { get; set; }
+
+        [Parameter("address[]", "approvedTargets", 3)]
+        public virtual List<string> ApprovedTargets { get; set; }
+
+        [Parameter("uint256", "nativeTokenLimitPerTransaction", 4)]
+        public virtual BigInteger NativeTokenLimitPerTransaction { get; set; }
+
+        [Parameter("uint128", "permissionStartTimestamp", 5)]
+        public virtual BigInteger PermissionStartTimestamp { get; set; }
+
+        [Parameter("uint128", "permissionEndTimestamp", 6)]
+        public virtual BigInteger PermissionEndTimestamp { get; set; }
+
+        [Parameter("uint128", "reqValidityStartTimestamp", 7)]
+        public virtual BigInteger ReqValidityStartTimestamp { get; set; }
+
+        [Parameter("uint128", "reqValidityEndTimestamp", 8)]
+        public virtual BigInteger ReqValidityEndTimestamp { get; set; }
+
+        [Parameter("bytes32", "uid", 9)]
+        public virtual byte[] Uid { get; set; }
+    }
+}

Assets/Thirdweb/Core/Contract Definitions/Account/ContractDefinition/AccountDefinition.cs

@@ -7,18 +7,18 @@
 
 namespace Thirdweb.Contracts.Account.ContractDefinition
 {
-    public partial class RoleRestrictions : RoleRestrictionsBase { }
+    public partial class SignerPermissions : SignerPermissionsBase { }
 
-    public class RoleRestrictionsBase
+    public class SignerPermissionsBase
     {
-        [Parameter("bytes32", "role", 1)]
-        public virtual byte[] Role { get; set; }
+        [Parameter("address", "signer", 1)]
+        public virtual string Signer { get; set; }
 
         [Parameter("address[]", "approvedTargets", 2)]
         public virtual List<string> ApprovedTargets { get; set; }
 
-        [Parameter("uint256", "maxValuePerTransaction", 3)]
-        public virtual BigInteger MaxValuePerTransaction { get; set; }
+        [Parameter("uint256", "nativeTokenLimitPerTransaction", 3)]
+        public virtual BigInteger NativeTokenLimitPerTransaction { get; set; }
 
         [Parameter("uint128", "startTimestamp", 4)]
         public virtual BigInteger StartTimestamp { get; set; }

Assets/Thirdweb/Core/Contract Definitions/Account/ContractDefinition/RoleRequest.cs

@@ -114,6 +114,30 @@ public Task<TransactionReceipt> CreateAccountRequestAndWaitForReceiptAsync(strin
             return ContractHandler.SendRequestAndWaitForReceiptAsync(createAccountFunction, cancellationToken);
         }
 
+        public Task<string> EntrypointQueryAsync(EntrypointFunction entrypointFunction, BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<EntrypointFunction, string>(entrypointFunction, blockParameter);
+        }
+
+        public Task<string> EntrypointQueryAsync(BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<EntrypointFunction, string>(null, blockParameter);
+        }
+
+        public Task<List<string>> GetAccountsQueryAsync(GetAccountsFunction getAccountsFunction, BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<GetAccountsFunction, List<string>>(getAccountsFunction, blockParameter);
+        }
+
+        public Task<List<string>> GetAccountsQueryAsync(BigInteger start, BigInteger end, BlockParameter blockParameter = null)
+        {
+            var getAccountsFunction = new GetAccountsFunction();
+            getAccountsFunction.Start = start;
+            getAccountsFunction.End = end;
+
+            return ContractHandler.QueryAsync<GetAccountsFunction, List<string>>(getAccountsFunction, blockParameter);
+        }
+
         public Task<List<string>> GetAccountsOfSignerQueryAsync(GetAccountsOfSignerFunction getAccountsOfSignerFunction, BlockParameter blockParameter = null)
         {
             return ContractHandler.QueryAsync<GetAccountsOfSignerFunction, List<string>>(getAccountsOfSignerFunction, blockParameter);
@@ -141,6 +165,16 @@ public Task<string> GetAddressQueryAsync(string adminSigner, byte[] data, BlockP
             return ContractHandler.QueryAsync<GetAddressFunction, string>(getAddressFunction, blockParameter);
         }
 
+        public Task<List<string>> GetAllAccountsQueryAsync(GetAllAccountsFunction getAllAccountsFunction, BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<GetAllAccountsFunction, List<string>>(getAllAccountsFunction, blockParameter);
+        }
+
+        public Task<List<string>> GetAllAccountsQueryAsync(BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<GetAllAccountsFunction, List<string>>(null, blockParameter);
+        }
+
         public Task<byte[]> GetRoleAdminQueryAsync(GetRoleAdminFunction getRoleAdminFunction, BlockParameter blockParameter = null)
         {
             return ContractHandler.QueryAsync<GetRoleAdminFunction, byte[]>(getRoleAdminFunction, blockParameter);
@@ -181,19 +215,6 @@ public Task<BigInteger> GetRoleMemberCountQueryAsync(byte[] role, BlockParameter
             return ContractHandler.QueryAsync<GetRoleMemberCountFunction, BigInteger>(getRoleMemberCountFunction, blockParameter);
         }
 
-        public Task<List<string>> GetSignersOfAccountQueryAsync(GetSignersOfAccountFunction getSignersOfAccountFunction, BlockParameter blockParameter = null)
-        {
-            return ContractHandler.QueryAsync<GetSignersOfAccountFunction, List<string>>(getSignersOfAccountFunction, blockParameter);
-        }
-
-        public Task<List<string>> GetSignersOfAccountQueryAsync(string account, BlockParameter blockParameter = null)
-        {
-            var getSignersOfAccountFunction = new GetSignersOfAccountFunction();
-            getSignersOfAccountFunction.Account = account;
-
-            return ContractHandler.QueryAsync<GetSignersOfAccountFunction, List<string>>(getSignersOfAccountFunction, blockParameter);
-        }
-
         public Task<string> GrantRoleRequestAsync(GrantRoleFunction grantRoleFunction)
         {
             return ContractHandler.SendRequestAsync(grantRoleFunction);
@@ -250,6 +271,47 @@ public Task<bool> HasRoleWithSwitchQueryAsync(byte[] role, string account, Block
             return ContractHandler.QueryAsync<HasRoleWithSwitchFunction, bool>(hasRoleWithSwitchFunction, blockParameter);
         }
 
+        public Task<string> InitializeRequestAsync(InitializeFunction initializeFunction)
+        {
+            return ContractHandler.SendRequestAsync(initializeFunction);
+        }
+
+        public Task<TransactionReceipt> InitializeRequestAndWaitForReceiptAsync(InitializeFunction initializeFunction, CancellationTokenSource cancellationToken = null)
+        {
+            return ContractHandler.SendRequestAndWaitForReceiptAsync(initializeFunction, cancellationToken);
+        }
+
+        public Task<string> InitializeRequestAsync(string defaultAdmin, string contractURI)
+        {
+            var initializeFunction = new InitializeFunction();
+            initializeFunction.DefaultAdmin = defaultAdmin;
+            initializeFunction.ContractURI = contractURI;
+
+            return ContractHandler.SendRequestAsync(initializeFunction);
+        }
+
+        public Task<TransactionReceipt> InitializeRequestAndWaitForReceiptAsync(string defaultAdmin, string contractURI, CancellationTokenSource cancellationToken = null)
+        {
+            var initializeFunction = new InitializeFunction();
+            initializeFunction.DefaultAdmin = defaultAdmin;
+            initializeFunction.ContractURI = contractURI;
+
+            return ContractHandler.SendRequestAndWaitForReceiptAsync(initializeFunction, cancellationToken);
+        }
+
+        public Task<bool> IsRegisteredQueryAsync(IsRegisteredFunction isRegisteredFunction, BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<IsRegisteredFunction, bool>(isRegisteredFunction, blockParameter);
+        }
+
+        public Task<bool> IsRegisteredQueryAsync(string account, BlockParameter blockParameter = null)
+        {
+            var isRegisteredFunction = new IsRegisteredFunction();
+            isRegisteredFunction.Account = account;
+
+            return ContractHandler.QueryAsync<IsRegisteredFunction, bool>(isRegisteredFunction, blockParameter);
+        }
+
         public Task<string> MulticallRequestAsync(MulticallFunction multicallFunction)
         {
             return ContractHandler.SendRequestAsync(multicallFunction);
@@ -276,6 +338,32 @@ public Task<TransactionReceipt> MulticallRequestAndWaitForReceiptAsync(List<byte
             return ContractHandler.SendRequestAndWaitForReceiptAsync(multicallFunction, cancellationToken);
         }
 
+        public Task<string> OnRegisterRequestAsync(OnRegisterFunction onRegisterFunction)
+        {
+            return ContractHandler.SendRequestAsync(onRegisterFunction);
+        }
+
+        public Task<TransactionReceipt> OnRegisterRequestAndWaitForReceiptAsync(OnRegisterFunction onRegisterFunction, CancellationTokenSource cancellationToken = null)
+        {
+            return ContractHandler.SendRequestAndWaitForReceiptAsync(onRegisterFunction, cancellationToken);
+        }
+
+        public Task<string> OnRegisterRequestAsync(byte[] salt)
+        {
+            var onRegisterFunction = new OnRegisterFunction();
+            onRegisterFunction.Salt = salt;
+
+            return ContractHandler.SendRequestAsync(onRegisterFunction);
+        }
+
+        public Task<TransactionReceipt> OnRegisterRequestAndWaitForReceiptAsync(byte[] salt, CancellationTokenSource cancellationToken = null)
+        {
+            var onRegisterFunction = new OnRegisterFunction();
+            onRegisterFunction.Salt = salt;
+
+            return ContractHandler.SendRequestAndWaitForReceiptAsync(onRegisterFunction, cancellationToken);
+        }
+
         public Task<string> OnSignerAddedRequestAsync(OnSignerAddedFunction onSignerAddedFunction)
         {
             return ContractHandler.SendRequestAsync(onSignerAddedFunction);
@@ -286,18 +374,20 @@ public Task<TransactionReceipt> OnSignerAddedRequestAndWaitForReceiptAsync(OnSig
             return ContractHandler.SendRequestAndWaitForReceiptAsync(onSignerAddedFunction, cancellationToken);
         }
 
-        public Task<string> OnSignerAddedRequestAsync(string signer)
+        public Task<string> OnSignerAddedRequestAsync(string signer, byte[] salt)
         {
             var onSignerAddedFunction = new OnSignerAddedFunction();
             onSignerAddedFunction.Signer = signer;
+            onSignerAddedFunction.Salt = salt;
 
             return ContractHandler.SendRequestAsync(onSignerAddedFunction);
         }
 
-        public Task<TransactionReceipt> OnSignerAddedRequestAndWaitForReceiptAsync(string signer, CancellationTokenSource cancellationToken = null)
+        public Task<TransactionReceipt> OnSignerAddedRequestAndWaitForReceiptAsync(string signer, byte[] salt, CancellationTokenSource cancellationToken = null)
         {
             var onSignerAddedFunction = new OnSignerAddedFunction();
             onSignerAddedFunction.Signer = signer;
+            onSignerAddedFunction.Salt = salt;
 
             return ContractHandler.SendRequestAndWaitForReceiptAsync(onSignerAddedFunction, cancellationToken);
         }
@@ -312,18 +402,20 @@ public Task<TransactionReceipt> OnSignerRemovedRequestAndWaitForReceiptAsync(OnS
             return ContractHandler.SendRequestAndWaitForReceiptAsync(onSignerRemovedFunction, cancellationToken);
         }
 
-        public Task<string> OnSignerRemovedRequestAsync(string signer)
+        public Task<string> OnSignerRemovedRequestAsync(string signer, byte[] salt)
         {
             var onSignerRemovedFunction = new OnSignerRemovedFunction();
             onSignerRemovedFunction.Signer = signer;
+            onSignerRemovedFunction.Salt = salt;
 
             return ContractHandler.SendRequestAsync(onSignerRemovedFunction);
         }
 
-        public Task<TransactionReceipt> OnSignerRemovedRequestAndWaitForReceiptAsync(string signer, CancellationTokenSource cancellationToken = null)
+        public Task<TransactionReceipt> OnSignerRemovedRequestAndWaitForReceiptAsync(string signer, byte[] salt, CancellationTokenSource cancellationToken = null)
         {
             var onSignerRemovedFunction = new OnSignerRemovedFunction();
             onSignerRemovedFunction.Signer = signer;
+            onSignerRemovedFunction.Salt = salt;
 
             return ContractHandler.SendRequestAndWaitForReceiptAsync(onSignerRemovedFunction, cancellationToken);
         }
@@ -409,5 +501,15 @@ public Task<TransactionReceipt> SetContractURIRequestAndWaitForReceiptAsync(stri
 
             return ContractHandler.SendRequestAndWaitForReceiptAsync(setContractURIFunction, cancellationToken);
         }
+
+        public Task<BigInteger> TotalAccountsQueryAsync(TotalAccountsFunction totalAccountsFunction, BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<TotalAccountsFunction, BigInteger>(totalAccountsFunction, blockParameter);
+        }
+
+        public Task<BigInteger> TotalAccountsQueryAsync(BlockParameter blockParameter = null)
+        {
+            return ContractHandler.QueryAsync<TotalAccountsFunction, BigInteger>(null, blockParameter);
+        }
     }
 }

Assets/Thirdweb/Core/Contract Definitions/Account/ContractDefinition/SignerPermissionRequest.cs

@@ -16,6 +16,7 @@
 using Thirdweb.Redcode.Awaiting;
 using System.Threading;
 using System.Collections.Concurrent;
+using Thirdweb.Contracts.Account.ContractDefinition;
 
 namespace Thirdweb.AccountAbstraction
 {
@@ -70,19 +71,23 @@ internal async Task<string> GetPersonalAddress()
             return Nethereum.Util.AddressUtil.Current.ConvertToChecksumAddress(accounts[0]);
         }
 
-        internal async Task Initialize()
+        internal async Task Initialize(string smartWalletOverride = null)
         {
             if (_initialized)
                 return;
 
             PersonalAddress = await GetPersonalAddress();
 
-            var predictedAccount = await TransactionManager.ThirdwebRead<FactoryContract.GetAddressFunction, FactoryContract.GetAddressOutputDTO>(
-                Config.factoryAddress,
-                new FactoryContract.GetAddressFunction() { AdminSigner = PersonalAddress, Data = new byte[] { } }
-            );
+            var predictedAccount =
+                smartWalletOverride
+                ?? (
+                    await TransactionManager.ThirdwebRead<FactoryContract.GetAddressFunction, FactoryContract.GetAddressOutputDTO>(
+                        Config.factoryAddress,
+                        new FactoryContract.GetAddressFunction() { AdminSigner = PersonalAddress, Data = new byte[] { } }
+                    )
+                ).ReturnValue1;
 
-            Accounts = new List<string>() { predictedAccount.ReturnValue1 };
+            Accounts = new List<string>() { predictedAccount };
 
             await UpdateDeploymentStatus();
 
@@ -97,17 +102,20 @@ internal async Task UpdateDeploymentStatus()
             _deployed = bytecode != "0x";
         }
 
+        internal async Task<TransactionResult> SetPermissionsForSigner(SignerPermissionRequest signerPermissionRequest, byte[] signature)
+        {
+            return await TransactionManager.ThirdwebWrite(Accounts[0], new SetPermissionsForSignerFunction() { Req = signerPermissionRequest, Signature = signature });
+        }
+
         internal async Task ForceDeploy()
         {
             if (_deployed)
                 return;
 
-            _deploying = true;
             var input = new TransactionInput("0x", Accounts[0], new HexBigInteger(0));
             var txHash = await Request(new RpcRequestMessage(1, "eth_sendTransaction", input));
             await Transaction.WaitForTransactionResult(txHash.Result.ToString());
             await UpdateDeploymentStatus();
-            _deploying = false;
         }
 
         internal async Task<bool> VerifySignature(byte[] hash, byte[] signature)