update KeyList to Threshold Key verbage

Author: mgarbs

HIP/hip-1069.md

@@ -1,42 +1,42 @@
 ---
 hip: 1069
-title: Enable KeyList Support in HTS Token Creation and Update Operations
+title: Enable Threshold Key Support in HTS Token Creation and Update Operations
 author: Michael Garber <@michael.garber>
 working-group: Giuseppe Bertone <@giuseppebertone>, Nikolaos Kamarinakis <@nikolaoskamarinakis>
 requested-by: Axelar
 type: Standards Track
 category: Service
 needs-council-approval: Yes
-status: Draft
+status: Review
 created: 2024-10-31
 discussions-to: https://github.com/hashgraph/hedera-improvement-proposal/discussions/1069
-updated: 2024-10-31
+updated: 2024-01-16
 ---
 
 ## Abstract
-This HIP proposes an enhancement to the Hedera Token Service (HTS) precompile functions to support **KeyLists** in both token creation and key updates. Although KeyLists are supported within the SDK, they cannot currently be set through the HTS precompiles, which limits their usability in smart contracts for token management. Enabling KeyList support within the HTS precompiles would allow token keys managed by KeyLists to be set during creation and updated on-chain, adding significant flexibility for contract-based token operations.
+This HIP proposes an enhancement to the Hedera Token Service (HTS) precompile functions to support **Threshold Keys** in both token creation and key updates. Although Threshold Keys are supported within the SDK, they cannot currently be set through the HTS precompiles, which limits their usability in smart contracts for token management. Enabling Threshold Key support (with threshold=1) within the HTS precompiles would allow token keys managed by multiple administrators to be set during creation and updated on-chain, adding significant flexibility for contract-based token operations.
 
 ## Motivation
-The Hedera SDK allows setting KeyLists for token keys, which is a useful feature for multi-signature setups and threshold-based authorizations. However, the HTS precompile functions do not currently support KeyLists, making it impossible to create or update token keys with multiple signatories directly on-chain. This limitation creates a gap in functionality, especially for projects that rely heavily on multi-signature control within contract environments, such as Axelar's cross-chain integrations.
+The Hedera SDK allows setting Threshold Keys for token keys, which is a useful feature for administrative setups where multiple potential administrators need equal permissions. However, the HTS precompile functions do not currently support Threshold Keys, making it impossible to create or update token keys with multiple potential administrators directly on-chain. This limitation creates a gap in functionality, especially for projects that require flexible administrative control within contract environments, such as Axelar's cross-chain integrations.
 
 ## Rationale
-Supporting KeyLists directly within the token creation and update precompiles aligns with Hedera's goal of providing flexible, decentralized token management. By allowing contract-based applications to set KeyLists during token creation and subsequent updates, developers can enhance security and improve token access controls within contract-managed tokens, without needing to rely on external SDK calls or workarounds.
+Supporting Threshold Keys (threshold=1) directly within the token creation and update precompiles aligns with Hedera's goal of providing flexible, decentralized token management. By allowing contract-based applications to set Threshold Keys during token creation and subsequent updates, developers can implement multiple administrator scenarios where any one of the specified administrators can perform operations. This simplifies administrative control without needing to rely on external SDK calls or workarounds. Due to Ethereum's lack of native multi-signature transaction support, this implementation focuses on threshold=1 scenarios, which covers the primary use case of allowing multiple potential administrators with equal permissions.
 
 ## User Stories
-1. **As a developer** managing a cross-chain bridge, I want to create tokens with KeyLists and update token keys through HTS precompiles, allowing multiple signatories to authorize operations.
-2. **As a DApp creator**, I want to create tokens with a `KeyList` as the supply key and update it as needed, using a threshold mechanism to ensure decentralized control over supply adjustments.
-3. **As a DAO member**, I want to both create and update token keys on-chain using a `KeyList` to allow multi-signature voting for key management.
-4. **As a protocol developer**, I want to initialize tokens with KeyLists during creation to establish proper governance controls from the start.
+1. **As a developer** managing a cross-chain bridge, I want to create tokens with Threshold Keys and update token keys through HTS precompiles, allowing multiple potential administrators to authorize operations.
+2. **As a DApp creator**, I want to create tokens with a Threshold Key as the supply key and update it as needed, enabling multiple administrators to have equal permission to adjust supply.
+3. **As a DAO member**, I want to both create and update token keys on-chain using a Threshold Key to allow any approved administrator to manage key operations.
+4. **As a protocol developer**, I want to initialize tokens with Threshold Keys during creation to establish flexible administrative controls from the start, where any designated administrator can perform operations.
 
 ## Specification
-The following updates are proposed to the HTS precompile functions:
+The following updates are proposed to the HTS precompile functions to support Threshold Keys with threshold=1:
 
 ### Updated Token Creation Function
-Add support for `KeyList` types within the token creation parameters:
+Add support for Threshold Key types within the token creation parameters:
 
 ```solidity
-    /// Operation to create a token with KeyList support
-    /// @param token The token creation parameters, including KeyLists for multi-key support
+    /// Operation to create a token with Threshold Key support
+    /// @param token The token creation parameters, including Threshold Keys for multi-admin support
     /// @return responseCode The response code for the status of the request. SUCCESS is 22.
     /// @return tokenAddress The created token's address
     function createToken(
@@ -51,16 +51,16 @@ Add support for `KeyList` types within the token creation parameters:
         (responseCode, tokenAddress) = success
             ? abi.decode(result, (int32, address))
             : (HederaResponseCodes.UNKNOWN, address(0));
-    }
+    }   
 ```
 
 ### Updated `updateTokenKeys` Precompile Function
-Add support for `KeyList` types within `IHederaTokenService.TokenKey[]` in the `updateTokenKeys` function:
+Add support for Threshold Key types within `IHederaTokenService.TokenKey[]` in the `updateTokenKeys` function:
 
 ```solidity
-    /// Operation to update token keys with KeyList support
+    /// Operation to update token keys with Threshold Key support
     /// @param token The token address
-    /// @param keys The token keys, including KeyLists for multi-key support
+    /// @param keys The token keys, including Threshold Keys for multi-admin support
     /// @return responseCode The response code for the status of the request. SUCCESS is 22.
     function updateTokenKeys(
         address token,
@@ -82,19 +82,19 @@ Add support for `KeyList` types within `IHederaTokenService.TokenKey[]` in the `
 Example Usage for both operations:
 
 ```solidity
-    // KeyList definition
+    // Threshold Key definition (threshold=1)
     IHederaTokenService.TokenKey memory key = IHederaTokenService.TokenKey({
         keyType: KeyType.SUPPLY,
-        key: KeyList({
+        key: ThresholdKey({
             keys: [
                 Key(KeyType.ECDSA_SECP256K1, ecdsaPublicKey1),
                 Key(KeyType.CONTRACT_ID, contractId2)
             ],
-            threshold: 2
+            threshold: 1  // Any one administrator can perform operations
         })
     });
 
-    // Creation with KeyList
+    // Creation with Threshold Key
     IHederaTokenService.HederaToken memory tokenParams = IHederaTokenService.HederaToken({
         name: "Example Token",
         symbol: "EXT",
@@ -105,7 +105,7 @@ Example Usage for both operations:
 
     (int responseCode, address tokenAddress) = IHederaTokenService.createToken(tokenParams);
 
-    // Updating with KeyList
+    // Updating with Threshold Key
     IHederaTokenService.updateTokenKeys(tokenAddress, [key]);
 ```
 
@@ -116,13 +116,14 @@ No foreseen issues
 TBD
 
 ## How to Teach This
-This enhancement should be documented in the Hedera developer documentation, with examples on how to set KeyLists for token keys during both creation and updates using the HTS precompiles.
+This enhancement should be documented in the Hedera developer documentation, with examples on how to set Threshold Keys (threshold=1) for token keys during both creation and updates using the HTS precompiles, emphasizing the use case of enabling multiple potential administrators with equal permissions.
 
 ## Reference Implementation
-A reference implementation should mirror the specification given within the Hedera SDK to allow developers to use KeyLists within HTS precompiles for both token creation and updates, ensuring compatibility with both contract-based and SDK token operations.
+A reference implementation should mirror the specification given within the Hedera SDK to allow developers to use Threshold Keys within HTS precompiles for both token creation and updates, ensuring compatibility with both contract-based and SDK token operations.
 
 ## Rejected Ideas
-External SDK Workarounds: Using SDK calls outside of the smart contract was considered but found impractical for fully on-chain applications.
+1. External SDK Workarounds: Using SDK calls outside of the smart contract was considered but found impractical for fully on-chain applications.
+2. Support for Threshold Keys with threshold > 1: Due to Ethereum's lack of native multi-signature transaction support, implementing thresholds greater than 1 was deemed technically infeasible.
 
 ## Open Issues
 1.