From 4259123368fe528c7f2dd6a43064a3660cb342dd Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 31 Jul 2024 10:11:03 +0200 Subject: [PATCH 1/8] add custom improvement proposal doc --- .../custom-improvement-proposals.md | 121 ++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 docs/develop/smart-contracts/custom-improvement-proposals.md diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md new file mode 100644 index 0000000..8cedebf --- /dev/null +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -0,0 +1,121 @@ +# Custom Improvement Proposals + +With the release [v19.0.0](https://github.com/evmos/evmos/releases/tag/v19.0.0) +a new feature called custom improvement proposal has been introduced in the +evmOS framework. Custom improvement proposals allow protocol developers to +modify the behavior of the EVM opcodes to tailor their functionalities to the +specific needs. + +## Improvement Proposals + +Improvement proposals are a way to introduce new standards aimed to improve +protocol functionalities. Changes proposed in this way can affect any aspect +of protocol functionalities but are mainly used to customize the behavior of +smart contract execution. + +## Operations + +Operations are the base components of the Ethereum Virtual Machine (EVM) which +allows the execution of the smart contract logic. When a developer build a smart +contract, the code written in Solidity, or Viper, is not directly interpretable +by the EVM. Before being able to execute the code in the blockchain, the +contract has to be compiled via one of the available compilers, like `solc`. The +step of the compilation convert the contract, written in a human readable +language, into a sequence of operations that the virtual machine can interpret +and execute to perform state transition or query the latest committed state. +These operations are called, in the EVM context, **opcodes** and are contained +in a structure called **jump table**. + +Some example of operations are the addition, defined by the opcode `ADD`, and +the subtraction, defined by the opcode `SUB`. + +Each opcode is defined by specifying the logic that has to be executed when it +is called inside the EVM, its relationship with the memory, and the gas cost +associated with it. More specifically, an opcodes is completely defined by: + +- `SetExecute`: update the execution logic for the opcode. + +- `SetConstantGas`: update the value used for the constant gas cost. + +- `SetDynamicGas`: update the function used to compute the dynamic gas cost. + +- `SetMinStack`: update the minimum number of items in the stack required to +execute the `operation`. + +- `SetMaxStack`: update the maximum number of items that will be in the stack +after executing the `operation`. + +- `SetMemorySize`: the memory size required by the `operation`. + +Within evmOS framework, developer can modify any of the previous properties. + +## Improvement Proposals + +Improvement proposal are the approach used by evmOS and Ethereum to modify the +the behavior of opcodes. They are composed by a function, which have the access +to the jump table to apply specific changes to operations behavior, and a name. + +In the context of Ethereum, these protocol changes are +named Ethereum Improvement Proposals (EIPs) and are associated to a numerical +name. For example, the [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) is +used to introduce the base fee. + +To allow any evmOS user to define their specific +improvements without overlapping with evmOS and Ethereum default ones, each +proposal is identified by a string composed by the chain name and a number. For +example, default evmOS improvements are associated with the string `evmos_XXXX`. +In this way, every chain can define their improvement without the risk of +overwriting already present functions and is free to start the numeration from +0. + +Below an example of how Evmos chain uses this functionalities to modify the +behavior of the `CREATE` and `CREATE2` opcodes. First the modifier function has +to be defined: + +```go +// Enable0000 contains the logic to modify the CREATE and CREATE2 opcodes +// constant gas value. +func Enable0000(jt *vm.JumpTable) { + multiplier := 10 + + currentValCreate := jt[vm.CREATE].GetConstantGas() + jt[vm.CREATE].SetConstantGas(currentValCreate * multiplier) + + currentValCreate2 := jt[vm.CREATE2].GetConstantGas() + jt[vm.CREATE2].SetConstantGas(currentValCreate2 * multiplier) +} +``` + +then, the function as to be associated with a name via a custom activator: + +```go +evmosActivators = map[int]func(*vm.JumpTable){ + "evmos_0": eips.Enable0000, +} +``` + +## Activation of Improvement Proposals + +Due to continuous changes in the interaction of users with the protocol, and to +introduce a safety measure along with the freedom to customize the virtual +machine behavior, custom improvement proposals are not active by default. The +two just defined structures are used to define a modifier, and associate it with +a namespace. The activation of selected improvement proposals is made via +`x/evm` parameters. It is possible to activate specific improvement proposals in +two ways: + +1. Upgrade: create a protocol upgrade handler that introduce the proposal name +in the active list. + +2. Governance: create governance proposal to activate a improvement that is +registered in the custom activator. + +With this approach, it is given to developers the possibility to quickly react +to security issues or market conditions, still keeping chain's participants in +the loop. + +## Additional Resources + +1. [Evmos Custom EIPs](https://github.com/evmos/evmos/blob/main/app/eips/README.md): +please refer to this document for a detailed description of how opcodes and +custom improvement proposals has to be used in the evmOS framework. From a4a246d9088451c501ebdfd7b8b3a9f9a19acbf9 Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 31 Jul 2024 10:22:35 +0200 Subject: [PATCH 2/8] lint --- .../smart-contracts/custom-improvement-proposals.md | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md index 8cedebf..9de5519 100644 --- a/docs/develop/smart-contracts/custom-improvement-proposals.md +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -4,11 +4,9 @@ With the release [v19.0.0](https://github.com/evmos/evmos/releases/tag/v19.0.0) a new feature called custom improvement proposal has been introduced in the evmOS framework. Custom improvement proposals allow protocol developers to modify the behavior of the EVM opcodes to tailor their functionalities to the -specific needs. +specific needs. -## Improvement Proposals - -Improvement proposals are a way to introduce new standards aimed to improve +Improvement proposals are a way to introduce new standards, aimed to improve protocol functionalities. Changes proposed in this way can affect any aspect of protocol functionalities but are mainly used to customize the behavior of smart contract execution. @@ -58,7 +56,7 @@ to the jump table to apply specific changes to operations behavior, and a name. In the context of Ethereum, these protocol changes are named Ethereum Improvement Proposals (EIPs) and are associated to a numerical name. For example, the [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) is -used to introduce the base fee. +used to introduce the base fee. To allow any evmOS user to define their specific improvements without overlapping with evmOS and Ethereum default ones, each From aa0a186ed451ebe3d53fa2129ae89d0bec94ee11 Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 31 Jul 2024 10:32:35 +0200 Subject: [PATCH 3/8] minor fixes --- .../custom-improvement-proposals.md | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md index 9de5519..46d748f 100644 --- a/docs/develop/smart-contracts/custom-improvement-proposals.md +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -1,27 +1,27 @@ # Custom Improvement Proposals With the release [v19.0.0](https://github.com/evmos/evmos/releases/tag/v19.0.0) -a new feature called custom improvement proposal has been introduced in the +a new feature called custom improvement proposals has been introduced in the evmOS framework. Custom improvement proposals allow protocol developers to modify the behavior of the EVM opcodes to tailor their functionalities to the specific needs. Improvement proposals are a way to introduce new standards, aimed to improve protocol functionalities. Changes proposed in this way can affect any aspect -of protocol functionalities but are mainly used to customize the behavior of +of the protocol but are mainly used to customize the behavior of smart contract execution. ## Operations Operations are the base components of the Ethereum Virtual Machine (EVM) which -allows the execution of the smart contract logic. When a developer build a smart +allow the execution of the smart contract logic. When a developer build a smart contract, the code written in Solidity, or Viper, is not directly interpretable by the EVM. Before being able to execute the code in the blockchain, the -contract has to be compiled via one of the available compilers, like `solc`. The -step of the compilation convert the contract, written in a human readable +contract has to be compiled via one of the available compilers, like **solc**. The +step of the compilation, convert the contract, written in a human readable language, into a sequence of operations that the virtual machine can interpret and execute to perform state transition or query the latest committed state. -These operations are called, in the EVM context, **opcodes** and are contained +These operations are called, in the EVM context, **opcodes**, and are contained in a structure called **jump table**. Some example of operations are the addition, defined by the opcode `ADD`, and @@ -38,19 +38,19 @@ associated with it. More specifically, an opcodes is completely defined by: - `SetDynamicGas`: update the function used to compute the dynamic gas cost. - `SetMinStack`: update the minimum number of items in the stack required to -execute the `operation`. +execute the operation. - `SetMaxStack`: update the maximum number of items that will be in the stack -after executing the `operation`. +after executing the operation. -- `SetMemorySize`: the memory size required by the `operation`. +- `SetMemorySize`: the memory size required by the operation. -Within evmOS framework, developer can modify any of the previous properties. +Within the evmOS framework, developers can modify any of the previous properties. ## Improvement Proposals Improvement proposal are the approach used by evmOS and Ethereum to modify the -the behavior of opcodes. They are composed by a function, which have the access +behavior of opcodes. They are composed by a function, which have the access to the jump table to apply specific changes to operations behavior, and a name. In the context of Ethereum, these protocol changes are @@ -62,9 +62,9 @@ To allow any evmOS user to define their specific improvements without overlapping with evmOS and Ethereum default ones, each proposal is identified by a string composed by the chain name and a number. For example, default evmOS improvements are associated with the string `evmos_XXXX`. -In this way, every chain can define their improvement without the risk of -overwriting already present functions and is free to start the numeration from -0. +In this way, each chain can define their improvement without the risk of +overwriting already present functions, and is free to start the numeration from +0 to have a more consistent history. Below an example of how Evmos chain uses this functionalities to modify the behavior of the `CREATE` and `CREATE2` opcodes. First the modifier function has @@ -84,7 +84,7 @@ func Enable0000(jt *vm.JumpTable) { } ``` -then, the function as to be associated with a name via a custom activator: +Then, the function as to be associated with a name via a custom activator: ```go evmosActivators = map[int]func(*vm.JumpTable){ @@ -94,7 +94,7 @@ evmosActivators = map[int]func(*vm.JumpTable){ ## Activation of Improvement Proposals -Due to continuous changes in the interaction of users with the protocol, and to +Due to continuous changes in the users interaction with the protocol, and to introduce a safety measure along with the freedom to customize the virtual machine behavior, custom improvement proposals are not active by default. The two just defined structures are used to define a modifier, and associate it with @@ -102,10 +102,10 @@ a namespace. The activation of selected improvement proposals is made via `x/evm` parameters. It is possible to activate specific improvement proposals in two ways: -1. Upgrade: create a protocol upgrade handler that introduce the proposal name +1. **Upgrade**: create a protocol upgrade handler which introduces the proposal name in the active list. -2. Governance: create governance proposal to activate a improvement that is +2. **Governance**: create governance proposal to activate an improvement that is registered in the custom activator. With this approach, it is given to developers the possibility to quickly react From 30bf916d92f0ec0a85279d48d333fa16e1cac4b7 Mon Sep 17 00:00:00 2001 From: MalteHerrmann <42640438+MalteHerrmann@users.noreply.github.com> Date: Wed, 31 Jul 2024 12:16:51 +0200 Subject: [PATCH 4/8] Apply suggestions from code review --- .../custom-improvement-proposals.md | 62 +++++++++---------- 1 file changed, 28 insertions(+), 34 deletions(-) diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md index 46d748f..1baaaf2 100644 --- a/docs/develop/smart-contracts/custom-improvement-proposals.md +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -14,18 +14,15 @@ smart contract execution. ## Operations Operations are the base components of the Ethereum Virtual Machine (EVM) which -allow the execution of the smart contract logic. When a developer build a smart +allow the execution of the smart contract logic. When a developer builds a smart contract, the code written in Solidity, or Viper, is not directly interpretable by the EVM. Before being able to execute the code in the blockchain, the -contract has to be compiled via one of the available compilers, like **solc**. The -step of the compilation, convert the contract, written in a human readable -language, into a sequence of operations that the virtual machine can interpret -and execute to perform state transition or query the latest committed state. -These operations are called, in the EVM context, **opcodes**, and are contained -in a structure called **jump table**. - -Some example of operations are the addition, defined by the opcode `ADD`, and -the subtraction, defined by the opcode `SUB`. +contract has to be compiled via one of the available compilers, like [solc](https://docs.soliditylang.org/en/latest/using-the-compiler.html). The +compilation converts the human readable contract code into a sequence of operations +that the virtual machine can interpret and execute +to perform state transitions or query the latest committed state. +These operations are called **opcodes**, and are contained +in a structure called [**jump table**](https://github.com/evmos/evmos/blob/v19.0.0/x/evm/core/vm/jump_table.go#L120-L1094). Each opcode is defined by specifying the logic that has to be executed when it is called inside the EVM, its relationship with the memory, and the gas cost @@ -49,25 +46,26 @@ Within the evmOS framework, developers can modify any of the previous properties ## Improvement Proposals -Improvement proposal are the approach used by evmOS and Ethereum to modify the -behavior of opcodes. They are composed by a function, which have the access +Improvement proposals are the approach used by evmOS and Ethereum to modify the +behavior of opcodes. They are composed by a function, which has access to the jump table to apply specific changes to operations behavior, and a name. In the context of Ethereum, these protocol changes are -named Ethereum Improvement Proposals (EIPs) and are associated to a numerical -name. For example, the [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) is +named Ethereum Improvement Proposals (EIPs) and are identified by a unique ID. +For example, [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) is used to introduce the base fee. -To allow any evmOS user to define their specific -improvements without overlapping with evmOS and Ethereum default ones, each -proposal is identified by a string composed by the chain name and a number. For +To allow any evmOS partner to define their own specific +improvements without overlapping with evmOS and Ethereum ones, each +proposal is identified by a string, that is composed of the chain name and a number. For example, default evmOS improvements are associated with the string `evmos_XXXX`. -In this way, each chain can define their improvement without the risk of -overwriting already present functions, and is free to start the numeration from -0 to have a more consistent history. +This allows each chain to define their improvements without having to worry +about existing or future ID clashes between different chains. +On top of that, the ability to start enumeration at 0 is better to handle for chain developers +and allows to have a better overview of the historical progress for each chain. -Below an example of how Evmos chain uses this functionalities to modify the -behavior of the `CREATE` and `CREATE2` opcodes. First the modifier function has +Below you will find an example of how the Evmos chain uses this functionality to modify the +behavior of the `CREATE` and `CREATE2` opcodes. First, the modifier function has to be defined: ```go @@ -87,7 +85,7 @@ func Enable0000(jt *vm.JumpTable) { Then, the function as to be associated with a name via a custom activator: ```go -evmosActivators = map[int]func(*vm.JumpTable){ +evmosActivators = map[string]func(*vm.JumpTable){ "evmos_0": eips.Enable0000, } ``` @@ -96,24 +94,20 @@ evmosActivators = map[int]func(*vm.JumpTable){ Due to continuous changes in the users interaction with the protocol, and to introduce a safety measure along with the freedom to customize the virtual -machine behavior, custom improvement proposals are not active by default. The -two just defined structures are used to define a modifier, and associate it with -a namespace. The activation of selected improvement proposals is made via -`x/evm` parameters. It is possible to activate specific improvement proposals in -two ways: +machine behavior, custom improvement proposals are not active by default. +The activation of selected improvement proposals is controlled by the [EVM module's parameters](https://github.com/evmos/evmos/blob/main/proto/ethermint/evm/v1/evm.proto#L17-L18). +There are two ways of introducing the required parameter changes: 1. **Upgrade**: create a protocol upgrade handler which introduces the proposal name in the active list. -2. **Governance**: create governance proposal to activate an improvement that is -registered in the custom activator. +2. **Governance**: create governance proposal to add an improvement proposal to the EVM module parameters. -With this approach, it is given to developers the possibility to quickly react -to security issues or market conditions, still keeping chain's participants in -the loop. +This approach gives developers the ability to react to security issues or market conditions, +while keeping the chain's participants in the loop. ## Additional Resources 1. [Evmos Custom EIPs](https://github.com/evmos/evmos/blob/main/app/eips/README.md): please refer to this document for a detailed description of how opcodes and -custom improvement proposals has to be used in the evmOS framework. +custom improvement proposals have to be used in the evmOS framework. From e1f1eca6cae513f57b12885c3deb1e7405407784 Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 31 Jul 2024 12:25:54 +0200 Subject: [PATCH 5/8] linter + fix --- .../custom-improvement-proposals.md | 25 ++++++++++--------- 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md index 1baaaf2..cd8e62a 100644 --- a/docs/develop/smart-contracts/custom-improvement-proposals.md +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -17,8 +17,9 @@ Operations are the base components of the Ethereum Virtual Machine (EVM) which allow the execution of the smart contract logic. When a developer builds a smart contract, the code written in Solidity, or Viper, is not directly interpretable by the EVM. Before being able to execute the code in the blockchain, the -contract has to be compiled via one of the available compilers, like [solc](https://docs.soliditylang.org/en/latest/using-the-compiler.html). The -compilation converts the human readable contract code into a sequence of operations +contract has to be compiled via one of the available compilers, like +[solc](https://docs.soliditylang.org/en/latest/using-the-compiler.html). The +compilation converts the human-readable contract code into a sequence of operations that the virtual machine can interpret and execute to perform state transitions or query the latest committed state. These operations are called **opcodes**, and are contained @@ -26,28 +27,28 @@ in a structure called [**jump table**](https://github.com/evmos/evmos/blob/v19.0 Each opcode is defined by specifying the logic that has to be executed when it is called inside the EVM, its relationship with the memory, and the gas cost -associated with it. More specifically, an opcodes is completely defined by: +associated with it. More specifically, an opcode is completely defined by: -- `SetExecute`: update the execution logic for the opcode. +- `SetExecute` update the execution logic for the opcode. -- `SetConstantGas`: update the value used for the constant gas cost. +- `SetConstantGas` update the value used for the constant gas cost. -- `SetDynamicGas`: update the function used to compute the dynamic gas cost. +- `SetDynamicGas` update the function used to compute the dynamic gas cost. -- `SetMinStack`: update the minimum number of items in the stack required to +- `SetMinStack` update the minimum number of items in the stack required to execute the operation. -- `SetMaxStack`: update the maximum number of items that will be in the stack +- `SetMaxStack` update the maximum number of items that will be in the stack after executing the operation. -- `SetMemorySize`: the memory size required by the operation. +- `SetMemorySize` the memory size required by the operation. Within the evmOS framework, developers can modify any of the previous properties. ## Improvement Proposals Improvement proposals are the approach used by evmOS and Ethereum to modify the -behavior of opcodes. They are composed by a function, which has access +behavior of opcodes. They are composed of a function, which has access to the jump table to apply specific changes to operations behavior, and a name. In the context of Ethereum, these protocol changes are @@ -64,7 +65,7 @@ about existing or future ID clashes between different chains. On top of that, the ability to start enumeration at 0 is better to handle for chain developers and allows to have a better overview of the historical progress for each chain. -Below you will find an example of how the Evmos chain uses this functionality to modify the +Below, you will find an example of how the Evmos chain uses this functionality to modify the behavior of the `CREATE` and `CREATE2` opcodes. First, the modifier function has to be defined: @@ -94,7 +95,7 @@ evmosActivators = map[string]func(*vm.JumpTable){ Due to continuous changes in the users interaction with the protocol, and to introduce a safety measure along with the freedom to customize the virtual -machine behavior, custom improvement proposals are not active by default. +machine behavior, custom improvement proposals are not active by default. The activation of selected improvement proposals is controlled by the [EVM module's parameters](https://github.com/evmos/evmos/blob/main/proto/ethermint/evm/v1/evm.proto#L17-L18). There are two ways of introducing the required parameter changes: From b22e931e28c486a005ddb293ea0bd3b844c0cde4 Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 31 Jul 2024 14:44:33 +0200 Subject: [PATCH 6/8] improve style --- .../smart-contracts/custom-improvement-proposals.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md index cd8e62a..6933c1a 100644 --- a/docs/develop/smart-contracts/custom-improvement-proposals.md +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -29,19 +29,19 @@ Each opcode is defined by specifying the logic that has to be executed when it is called inside the EVM, its relationship with the memory, and the gas cost associated with it. More specifically, an opcode is completely defined by: -- `SetExecute` update the execution logic for the opcode. +- `SetExecute`: update the execution logic for the opcode. -- `SetConstantGas` update the value used for the constant gas cost. +- `SetConstantGas`: update the value used for the constant gas cost. -- `SetDynamicGas` update the function used to compute the dynamic gas cost. +- `SetDynamicGas`: update the function used to compute the dynamic gas cost. -- `SetMinStack` update the minimum number of items in the stack required to +- `SetMinStack`: update the minimum number of items in the stack required to execute the operation. -- `SetMaxStack` update the maximum number of items that will be in the stack +- `SetMaxStack`: update the maximum number of items that will be in the stack after executing the operation. -- `SetMemorySize` the memory size required by the operation. +- `SetMemorySize`: the memory size required by the operation. Within the evmOS framework, developers can modify any of the previous properties. From 3ab04379ff675545e8bfb0bfc1412519eaf8c4dc Mon Sep 17 00:00:00 2001 From: MalteHerrmann <42640438+MalteHerrmann@users.noreply.github.com> Date: Wed, 31 Jul 2024 14:45:38 +0200 Subject: [PATCH 7/8] Apply suggestions from code review Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- .../smart-contracts/custom-improvement-proposals.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md index 6933c1a..130f5ff 100644 --- a/docs/develop/smart-contracts/custom-improvement-proposals.md +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -15,7 +15,7 @@ smart contract execution. Operations are the base components of the Ethereum Virtual Machine (EVM) which allow the execution of the smart contract logic. When a developer builds a smart -contract, the code written in Solidity, or Viper, is not directly interpretable +contract, the code written in Solidity, or Vyper, is not directly interpretable by the EVM. Before being able to execute the code in the blockchain, the contract has to be compiled via one of the available compilers, like [solc](https://docs.soliditylang.org/en/latest/using-the-compiler.html). The @@ -49,7 +49,7 @@ Within the evmOS framework, developers can modify any of the previous properties Improvement proposals are the approach used by evmOS and Ethereum to modify the behavior of opcodes. They are composed of a function, which has access -to the jump table to apply specific changes to operations behavior, and a name. +to the jump table to apply specific changes to operation behavior, and a name. In the context of Ethereum, these protocol changes are named Ethereum Improvement Proposals (EIPs) and are identified by a unique ID. @@ -62,8 +62,8 @@ proposal is identified by a string, that is composed of the chain name and a num example, default evmOS improvements are associated with the string `evmos_XXXX`. This allows each chain to define their improvements without having to worry about existing or future ID clashes between different chains. -On top of that, the ability to start enumeration at 0 is better to handle for chain developers -and allows to have a better overview of the historical progress for each chain. +Additionally, the ability to start enumeration at 0 is better for chain developers +and allows having a better overview of the historical progress for each chain. Below, you will find an example of how the Evmos chain uses this functionality to modify the behavior of the `CREATE` and `CREATE2` opcodes. First, the modifier function has @@ -93,7 +93,7 @@ evmosActivators = map[string]func(*vm.JumpTable){ ## Activation of Improvement Proposals -Due to continuous changes in the users interaction with the protocol, and to +Due to continuous changes in the users' interaction with the protocol, and to introduce a safety measure along with the freedom to customize the virtual machine behavior, custom improvement proposals are not active by default. The activation of selected improvement proposals is controlled by the [EVM module's parameters](https://github.com/evmos/evmos/blob/main/proto/ethermint/evm/v1/evm.proto#L17-L18). From 28d0d9a7e33d1983379a3e25098b930ac8bd54bd Mon Sep 17 00:00:00 2001 From: MalteHerrmann <42640438+MalteHerrmann@users.noreply.github.com> Date: Wed, 31 Jul 2024 14:46:48 +0200 Subject: [PATCH 8/8] Update docs/develop/smart-contracts/custom-improvement-proposals.md --- docs/develop/smart-contracts/custom-improvement-proposals.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/docs/develop/smart-contracts/custom-improvement-proposals.md b/docs/develop/smart-contracts/custom-improvement-proposals.md index 130f5ff..5efd130 100644 --- a/docs/develop/smart-contracts/custom-improvement-proposals.md +++ b/docs/develop/smart-contracts/custom-improvement-proposals.md @@ -6,11 +6,6 @@ evmOS framework. Custom improvement proposals allow protocol developers to modify the behavior of the EVM opcodes to tailor their functionalities to the specific needs. -Improvement proposals are a way to introduce new standards, aimed to improve -protocol functionalities. Changes proposed in this way can affect any aspect -of the protocol but are mainly used to customize the behavior of -smart contract execution. - ## Operations Operations are the base components of the Ethereum Virtual Machine (EVM) which