Switches over to Yul.

This shrinks the runtime costs quite a bit, as well as reducing the deployment costs notably.

Author: Micah Zoltu

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "compile",
+			"cwd": "${workspaceFolder}",
+			"runtimeArgs": [ "-r", "ts-node/register", ],
+			"args": [ "${workspaceFolder}/scripts/compile.ts", ],
+			"env": {
+				"TS_NODE_PROJECT": "${workspaceFolder}/tsconfig.json",
+			}
+		},
+	]
+}

scripts/compile.ts

@@ -1,6 +1,5 @@
 import { promises as filesystem } from 'fs'
 import * as path from 'path'
-import { AbiFunction, AbiEvent } from 'ethereum'
 import { CompilerOutput, CompilerInput, compileStandardWrapper, CompilerOutputContract } from 'solc'
 import { rlpEncode } from '@zoltu/rlp-encoder'
 import { keccak256 } from 'js-sha3'
@@ -18,34 +17,35 @@ export async function ensureDirectoryExists(absoluteDirectoryPath: string) {
 
 async function doStuff() {
 	const compilerOutput = await compileContracts()
-	const contract = compilerOutput.contracts['deterministic-deployment-proxy.sol']['DeterministicDeploymentProxy']
+	const contract = compilerOutput.contracts['deterministic-deployment-proxy.yul']['Proxy']
 	await ensureDirectoryExists(path.join(__dirname, '..', '/output/'))
-	await writeAbiJson(contract.abi)
 	await writeBytecode(contract.evm.bytecode.object)
 	await writeFactoryDeployerTransaction(contract)
 }
 
 async function compileContracts(): Promise<CompilerOutput> {
-	const solidityFilePath = path.join(__dirname, '..', 'source', 'deterministic-deployment-proxy.sol')
+	const solidityFilePath = path.join(__dirname, '..', 'source', 'deterministic-deployment-proxy.yul')
 	const soliditySourceCode = await filesystem.readFile(solidityFilePath, 'utf8')
 	const compilerInput: CompilerInput = {
-		language: "Solidity",
+		language: "Yul",
 		settings: {
 			optimizer: {
 				enabled: true,
-				runs: 500
+				details: {
+					yul: true,
+				},
 			},
 			outputSelection: {
 				"*": {
 					"*": [ "abi", "evm.bytecode.object", "evm.gasEstimates" ]
-				}
-			}
+				},
+			},
 		},
 		sources: {
-			'deterministic-deployment-proxy.sol': {
-				content: soliditySourceCode
-			}
-		}
+			'deterministic-deployment-proxy.yul': {
+				content: soliditySourceCode,
+			},
+		},
 	}
 	const compilerInputJson = JSON.stringify(compilerInput)
 	const compilerOutputJson = compileStandardWrapper(compilerInputJson)
@@ -55,6 +55,7 @@ async function compileContracts(): Promise<CompilerOutput> {
 		let concatenatedErrors = "";
 
 		for (let error of errors) {
+			if (/Yul is still experimental/.test(error.message)) continue
 			concatenatedErrors += error.formattedMessage + "\n";
 		}
 
@@ -66,20 +67,13 @@ async function compileContracts(): Promise<CompilerOutput> {
 	return compilerOutput
 }
 
-async function writeAbiJson(abi: (AbiFunction | AbiEvent)[]) {
-	const filePath = path.join(__dirname, '../output/abi.json')
-	const fileContents = JSON.stringify(abi, undefined, '\t')
-	return await filesystem.writeFile(filePath, fileContents, { encoding: 'utf8', flag: 'w' })
-}
-
 async function writeBytecode(bytecode: string) {
 	const filePath = path.join(__dirname, '..', 'output', `bytecode.txt`)
 	await filesystem.writeFile(filePath, bytecode, { encoding: 'utf8', flag: 'w' })
 }
 
 async function writeFactoryDeployerTransaction(contract: CompilerOutputContract) {
-	// https://github.com/ethereum/solidity/issues/6724 2x seems to be enough for this case... :this-is-fine:
-	const deploymentGas = Number.parseInt(contract.evm.gasEstimates!.creation.totalCost) * 2
+	const deploymentGas = 100000 // actual gas costs last measure: 59159; we don't want to run too close though because gas costs can change in forks and we want our address to be retained
 	const deploymentBytecode = contract.evm.bytecode.object
 
 	const nonce = new Uint8Array(0)

scripts/test.sh

@@ -3,7 +3,7 @@ set -x
 JSON_RPC="http://localhost:1234"
 
 # start geth in a local container
-GETH_CONTAINER_ID=$(docker container run --rm -d -p 1234:8545 -e GETH_VERBOSITY=3 keydonix/geth-clique)
+docker container run --rm -d --name deployment-proxy-geth -p 1234:8545 -e GETH_VERBOSITY=3 keydonix/geth-clique
 # wait for geth to become responsive
 until $(curl --output /dev/null --silent --fail $JSON_RPC -X 'POST' -H 'Content-Type: application/json' --data "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\": \"net_version\", \"params\": []}"); do sleep 1; done
 
@@ -22,19 +22,14 @@ curl $JSON_RPC -X 'POST' -H 'Content-Type: application/json' --data "{\"jsonrpc\
 
 # deploy our contract
 # contract: pragma solidity 0.5.8; contract Apple {function banana() external pure returns (uint8) {return 42;}}
-DEPLOY_SIGNATURE="9c4ae2d0"
-BYTECODE_OFFSET="0000000000000000000000000000000000000000000000000000000000000040"
-SALT="0000000000000000000000000000000000000000000000000000000000000000"
-BYTECODE_LENGTH="0000000000000000000000000000000000000000000000000000000000000098"
-BYTECODE="6080604052348015600f57600080fd5b50607a8061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063c3cafc6f14602d575b600080fd5b60336049565b6040805160ff9092168252519081900360200190f35b602a9056fea165627a7a7230582061b42c10c5aed258685366454ca535be5306e982bf70d72569122494bc53deb60029"
-PADDING="0000000000000000"
-curl $JSON_RPC -X 'POST' -H 'Content-Type: application/json' --data "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\": \"eth_sendTransaction\", \"params\": [{\"from\":\"$MY_ADDRESS\",\"to\":\"$DEPLOYER_ADDRESS\", \"data\":\"0x$DEPLOY_SIGNATURE$BYTECODE_OFFSET$SALT$BYTECODE_LENGTH$BYTECODE$PADDING\"}]}"
-
-# call our contract (we know the address, no matter what chain we ran this script against!)
-MY_CONTRACT_ADDRESS="0x8bb88a8d94804d59f8c2fb06d6605e288382e24f"
+BYTECODE="6080604052348015600f57600080fd5b5060848061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063c3cafc6f14602d575b600080fd5b6033604f565b604051808260ff1660ff16815260200191505060405180910390f35b6000602a90509056fea165627a7a72305820ab7651cb86b8c1487590004c2444f26ae30077a6b96c6bc62dda37f1328539250029"
+MY_CONTRACT_ADDRESS=$(curl $JSON_RPC -X 'POST' -H 'Content-Type: application/json' --silent --data "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\": \"eth_call\", \"params\": [{\"from\":\"$MY_ADDRESS\",\"to\":\"$DEPLOYER_ADDRESS\", \"data\":\"0x$BYTECODE\"}, \"latest\"]}" | jq --raw-output '.result')
+curl $JSON_RPC -X 'POST' -H 'Content-Type: application/json' --data "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\": \"eth_sendTransaction\", \"params\": [{\"from\":\"$MY_ADDRESS\",\"to\":\"$DEPLOYER_ADDRESS\", \"gas\":\"0xf4240\", \"data\":\"0x$BYTECODE\"}]}"
+
+# call our contract (NOTE: MY_CONTRACT_ADDRESS is the same no matter what chain we deploy to!)
 MY_CONTRACT_METHOD_SIGNATURE="c3cafc6f"
 curl $JSON_RPC -X 'POST' -H 'Content-Type: application/json' --data "{\"jsonrpc\":\"2.0\", \"id\":1, \"method\": \"eth_call\", \"params\": [{\"to\":\"$MY_CONTRACT_ADDRESS\", \"data\":\"0x$MY_CONTRACT_METHOD_SIGNATURE\"}, \"latest\"]}"
 # expected result is 0x000000000000000000000000000000000000000000000000000000000000002a (hex encoded 42)
 
 # shutdown Parity
-docker container stop $GETH_CONTAINER_ID
+docker container stop deployment-proxy-geth

scripts/typings/solc/index.d.ts

@@ -10,7 +10,7 @@ declare module 'solc' {
 		content: string;
 	}
 	interface CompilerInput {
-		language: "Solidity" | "serpent" | "lll" | "assembly";
+		language: "Solidity" | "serpent" | "lll" | "assembly" | "Yul";
 		settings?: any,
 		sources: {
 			[globalName: string]: CompilerInputSourceFile|CompilerInputSourceCode,

source/deterministic-deployment-proxy.sol

@@ -0,0 +1,16 @@
+object "Proxy" {
+	// deployment code
+	code {
+		let size := datasize("runtime")
+		datacopy(0, dataoffset("runtime"), size)
+		return(0, size)
+	}
+	object "runtime" {
+		// deployed code
+		code {
+			calldatacopy(0, 0, calldatasize())
+			mstore(0, create2(callvalue(), 0, calldatasize(), 0))
+			return(12, 20)
+		}
+	}
+}