HTS precompile token key management tests

packages/server/tests/acceptance/htsPrecompile.spec.ts

@@ -54,12 +54,15 @@ describe('@htsprecompile Acceptance Tests', async function () {
   let HTSTokenWithCustomFeesContractAddress;
 
   this.beforeAll(async () => {
-    accounts[0] = await servicesNode.createAliasAccount(170, relay.provider);
+    accounts[0] = await servicesNode.createAliasAccount(200, relay.provider);
     accounts[1] = await servicesNode.createAliasAccount(30, relay.provider);
     accounts[2] = await servicesNode.createAliasAccount(30, relay.provider);
 
-    // alow mirror node a 2 full record stream write windows (2 sec) and a buffer to persist setup details
+    // allow mirror node a 2 full record stream write windows (2 sec) and a buffer to persist setup details
     await new Promise(r => setTimeout(r, 5000));
+    await mirrorNode.get(`/accounts/${accounts[0].accountId}`);
+    await mirrorNode.get(`/accounts/${accounts[1].accountId}`);
+    await mirrorNode.get(`/accounts/${accounts[2].accountId}`);
 
     BaseHTSContractAddress = await deployBaseHTSContract();
     HTSTokenContractAddress = await createHTSToken();
@@ -499,7 +502,7 @@ describe('@htsprecompile Acceptance Tests', async function () {
       {
         const tx = await baseHTSContract.wipeTokenAccountNFTPublic(NftHTSTokenContractAddress, accounts[1].wallet.address, serials, { gasLimit: 1_000_000 });
         const { responseCode } = (await tx.wait()).events.filter(e => e.event === 'ResponseCode')[0].args;
-        console.log(`Wipe response: ${responseCode}`);
+        expect(responseCode).to.equal(TX_SUCCESS_CODE);
       }
 
       // Get token info after
@@ -660,7 +663,8 @@ describe('@htsprecompile Acceptance Tests', async function () {
         second: AUTO_RENEW_SECOND,
         autoRenewAccount: BaseHTSContractAddress,
         autoRenewPeriod: NEW_AUTO_RENEW_PERIOD
-      }
+      };
+
       const updateTokenExpiryInfoTx = (await baseHTSContract.updateTokenExpiryInfoPublic(NftHTSTokenContractAddress, expiryInfo, { gasLimit: 1_000_000 }));
       const updateExpiryInfoResponseCode = (await updateTokenExpiryInfoTx.wait()).events.filter(e => e.event === 'ResponseCode')[0].args.responseCode;
 
@@ -843,7 +847,7 @@ describe('@htsprecompile Acceptance Tests', async function () {
       }
     });
 
-    it('should fail to swap approved non-fungible tokens', async function() {        
+    it('should fail to swap approved non-fungible tokens', async function() {
       const txApprove1 = await baseHTSContract.setApprovalForAllPublic(NftHTSTokenContractAddress, accounts[1].wallet.address, true, { gasLimit: 1_000_000 });
       expect((await txApprove1.wait()).events.filter(e => e.event === 'ResponseCode')[0].args.responseCode).to.equal(TX_SUCCESS_CODE);
 
@@ -867,7 +871,7 @@ describe('@htsprecompile Acceptance Tests', async function () {
 
       try{
         const txXfer = await baseHTSContract.cryptoTransferPublic(tokenTransferList);
-        expect((await txXfer.wait()).events.filter(e => e.event === 'ResponseCode')[0].args.responseCode).to.equal(TX_SUCCESS_CODE);  
+        expect((await txXfer.wait()).events.filter(e => e.event === 'ResponseCode')[0].args.responseCode).to.equal(TX_SUCCESS_CODE);
       } catch (error: any) {
         expect(error.code).to.equal("CALL_EXCEPTION");
         expect(error.reason).to.equal("transaction failed");
@@ -904,4 +908,55 @@ describe('@htsprecompile Acceptance Tests', async function () {
       }
     });
   });
+
+
+  describe('HTS Precompile Key management Tests', async function() {
+    it('should be able to execute getTokenKey', async function() {
+      const tx = await baseHTSContract.getTokenKeyPublic(HTSTokenContractAddress, 2);
+      const result = await tx.wait();
+      const { responseCode } = result.events.filter(e => e.event === 'ResponseCode')[0].args;
+      expect(responseCode).to.equal(TX_SUCCESS_CODE);
+      const { key } = result.events.filter(e => e.event === 'TokenKey')[0].args;
+
+      expect(key).to.exist;
+      expect(key.inheritAccountKey).to.eq(false);
+      expect(key.contractId).to.eq('0x0000000000000000000000000000000000000000');
+      expect(key.ed25519).to.eq('0x');
+      expect(key.ECDSA_secp256k1).to.exist;
+      expect(key.delegatableContractId).to.eq('0x0000000000000000000000000000000000000000');
+    });
+
+    it('should be able to execute updateTokenKeys', async function() {
+      // Get key value before update
+      const getKeyTx = await baseHTSContract.getTokenKeyPublic(HTSTokenContractAddress, 2);
+      const originalKey = (await getKeyTx.wait()).events.filter(e => e.event === 'TokenKey')[0].args.key;
+      const updateKey = [
+        false,
+        '0x0000000000000000000000000000000000000000',
+        '0x',
+        '0x03dfcc94dfd843649cc594ada5ac6627031454602aa190223f996de25a05828f36',
+        '0x0000000000000000000000000000000000000000',
+      ];
+
+      // Update keys. After updating there should be only one key with keyValue = 6. Other keys are removed
+      const updateTx = await baseHTSContract.updateTokenKeysPublic(HTSTokenContractAddress, [[ 2, updateKey]]);
+      const updateResponseCode = (await updateTx.wait()).events.filter(e => e.event === 'ResponseCode')[0].args.responseCode;
+      expect(Number(updateResponseCode.toString())).to.equal(TX_SUCCESS_CODE);
+
+      // Assert updated key
+      const tx = await baseHTSContract.getTokenKeyPublic(HTSTokenContractAddress, 2);
+      const result = await tx.wait();
+      const {responseCode} = result.events.filter(e => e.event === 'ResponseCode')[0].args;
+      expect(Number(responseCode.toString())).to.equal(TX_SUCCESS_CODE);
+      const updatedKey = result.events.filter(e => e.event === 'TokenKey')[0].args.key;
+
+      expect(updatedKey).to.exist;
+      expect(updatedKey.inheritAccountKey).to.eq(updateKey[0]);
+      expect(updatedKey.contractId).to.eq(updateKey[1]);
+      expect(updatedKey.ed25519).to.eq(updateKey[2]);
+      expect(updatedKey.ECDSA_secp256k1).to.eq(updateKey[3]);
+      expect(updatedKey.delegatableContractId).to.eq(updateKey[4]);
+      expect(updatedKey.ECDSA_secp256k1).to.not.eq(originalKey.ECDSA_secp256k1);
+    });
+  });
 });

packages/server/tests/contracts/BaseHTS.sol

@@ -10,7 +10,7 @@ contract BaseHTS is FeeHelper {
     string symbol = "tokenSymbol";
     string memo = "memo";
     uint64 initialTotalSupply = 1000;
-    int64 maxSupply = 1000;
+    uint32 maxSupply = 1000;
     uint32 decimals = 8;
     bool freezeDefaultStatus = false;
 
@@ -30,6 +30,7 @@ contract BaseHTS is FeeHelper {
     event TokenCustomFees(IHederaTokenService.FixedFee[] fixedFees, IHederaTokenService.FractionalFee[] fractionalFees, IHederaTokenService.RoyaltyFee[] royaltyFees);
     event TokenDefaultFreezeStatus(bool defaultFreezeStatus);
     event TokenDefaultKycStatus(bool defaultKycStatus);
+    event TokenKey(IHederaTokenService.KeyValue key);
     event KycGranted(bool kycGranted);
     event TokenExpiryInfo(IHederaTokenService.Expiry expiryInfo);
 
@@ -450,4 +451,29 @@ contract BaseHTS is FeeHelper {
             revert();
         }
     }
+
+    function updateTokenKeysPublic(address token, IHederaTokenService.TokenKey[] memory keys)
+    public returns (int64 responseCode){
+
+        (responseCode) = HederaTokenService.updateTokenKeys(token, keys);
+
+        emit ResponseCode(responseCode);
+
+        if(responseCode != HederaResponseCodes.SUCCESS) {
+            revert();
+        }
+    }
+
+    function getTokenKeyPublic(address token, uint keyType)
+    public returns (int64 responseCode, IHederaTokenService.KeyValue memory key){
+        (responseCode, key) = HederaTokenService.getTokenKey(token, keyType);
+
+        emit ResponseCode(responseCode);
+
+        if(responseCode != HederaResponseCodes.SUCCESS) {
+            revert();
+        }
+
+        emit TokenKey(key);
+    }
 }

packages/server/tests/contracts/HederaTokenService.sol

@@ -30,7 +30,7 @@ abstract contract HederaTokenService is HederaResponseCodes {
     /// Initiates a Token Transfer
     /// @param tokenTransfers the list of transfers to do
     /// @return responseCode The response code for the status of the request. SUCCESS is 22.
-        function cryptoTransfer(IHederaTokenService.TokenTransferList[] memory tokenTransfers) internal
+    function cryptoTransfer(IHederaTokenService.TokenTransferList[] memory tokenTransfers) internal
     returns (int responseCode)
     {
         (bool success, bytes memory result) = precompileAddress.call(
@@ -556,6 +556,31 @@ abstract contract HederaTokenService is HederaResponseCodes {
         (responseCode) = success ? abi.decode(result, (int32)) : HederaResponseCodes.UNKNOWN;
     }
 
+    /// Operation to update token expiry info
+    /// @param token The token address
+    /// @param keys The token keys
+    /// @return responseCode The response code for the status of the request. SUCCESS is 22.
+    function updateTokenKeys(address token, IHederaTokenService.TokenKey[] memory keys)
+    internal returns (int64 responseCode){
+        (bool success, bytes memory result) = precompileAddress.call(
+            abi.encodeWithSelector(IHederaTokenService.updateTokenKeys.selector, token, keys));
+        (responseCode) = success ? abi.decode(result, (int32)) : HederaResponseCodes.UNKNOWN;
+    }
+
+    /// Query token KeyValue
+    /// @param token The token address to check
+    /// @param keyType The keyType of the desired KeyValue
+    /// @return responseCode The response code for the status of the request. SUCCESS is 22.
+    /// @return key KeyValue info for key of type `keyType`
+    function getTokenKey(address token, uint keyType)
+    internal returns (int64 responseCode, IHederaTokenService.KeyValue memory key){
+        (bool success, bytes memory result) = precompileAddress.call(
+            abi.encodeWithSelector(IHederaTokenService.getTokenKey.selector, token, keyType));
+        IHederaTokenService.KeyValue memory defaultKeyValueInfo;
+        (responseCode, key) = success ? abi.decode(result, (int32,IHederaTokenService.KeyValue) ) : (HederaResponseCodes.UNKNOWN, defaultKeyValueInfo);
+    }
+
+
     /// Operation to get token expiry info
     /// @param token The token address
     /// @return responseCode The response code for the status of the request. SUCCESS is 22.

packages/server/tests/contracts/IHederaTokenService.json

@@ -2086,6 +2086,62 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "keyType",
+          "type": "uint256"
+        }
+      ],
+      "name": "getTokenKey",
+      "outputs": [
+        {
+          "internalType": "int64",
+          "name": "responseCode",
+          "type": "int64"
+        },
+        {
+          "components": [
+            {
+              "internalType": "bool",
+              "name": "inheritAccountKey",
+              "type": "bool"
+            },
+            {
+              "internalType": "address",
+              "name": "contractId",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes",
+              "name": "ed25519",
+              "type": "bytes"
+            },
+            {
+              "internalType": "bytes",
+              "name": "ECDSA_secp256k1",
+              "type": "bytes"
+            },
+            {
+              "internalType": "address",
+              "name": "delegatableContractId",
+              "type": "address"
+            }
+          ],
+          "internalType": "struct IHederaTokenService.KeyValue",
+          "name": "key",
+          "type": "tuple"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -2528,6 +2584,69 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "components": [
+            {
+              "internalType": "uint256",
+              "name": "keyType",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "bool",
+                  "name": "inheritAccountKey",
+                  "type": "bool"
+                },
+                {
+                  "internalType": "address",
+                  "name": "contractId",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "ed25519",
+                  "type": "bytes"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "ECDSA_secp256k1",
+                  "type": "bytes"
+                },
+                {
+                  "internalType": "address",
+                  "name": "delegatableContractId",
+                  "type": "address"
+                }
+              ],
+              "internalType": "struct IHederaTokenService.KeyValue",
+              "name": "key",
+              "type": "tuple"
+            }
+          ],
+          "internalType": "struct IHederaTokenService.TokenKey[]",
+          "name": "keys",
+          "type": "tuple[]"
+        }
+      ],
+      "name": "updateTokenKeys",
+      "outputs": [
+        {
+          "internalType": "int64",
+          "name": "responseCode",
+          "type": "int64"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {

packages/server/tests/contracts/IHederaTokenService.sol

@@ -407,6 +407,15 @@ interface IHederaTokenService {
     /// @param token The ID of the token as a solidity address
     function getTokenInfo(address token) external returns (int responseCode, TokenInfo memory tokenInfo);
 
+    /// Query token KeyValue
+    /// @param token The token address to check
+    /// @param keyType The keyType of the desired KeyValue
+    /// @return responseCode The response code for the status of the request. SUCCESS is 22.
+    /// @return key KeyValue info for key of type `keyType`
+    function getTokenKey(address token, uint keyType)
+    external
+    returns (int64 responseCode, KeyValue memory key);
+
     /// Retrieves non-fungible specific token info for a given NFT
     /// @param token The ID of the token as a solidity address
     /// @param serialNumber The serial number of the NFT for which to retrieve information
@@ -617,4 +626,12 @@ interface IHederaTokenService {
     /// @param token The token address
     /// @return responseCode The response code for the status of the request. SUCCESS is 22.
     function updateTokenExpiryInfo(address token, Expiry memory expiryInfo) external returns (int responseCode);
+
+    /// Operation to update token keys
+    /// @param token The token address
+    /// @param keys The token keys
+    /// @return responseCode The response code for the status of the request. SUCCESS is 22.
+    function updateTokenKeys(address token, TokenKey[] memory keys)
+    external
+    returns (int64 responseCode);
 }