precompute address is correct

NethermindEth · Jul 28, 2023 · 427ddfb · 427ddfb
1 parent 03f0fc5
commit 427ddfb
Show file tree

Hide file tree

Showing 2 changed files with 37 additions and 32 deletions.
diff --git a/examples/deployAccount/README.md b/examples/deployAccount/README.md
@@ -0,0 +1 @@
+This example uses a pre-deployed contract on testnet to deploy the account. For devnet, you would need to deploy your own contract first.
diff --git a/examples/deployAccount/main.go b/examples/deployAccount/main.go
@@ -19,7 +19,6 @@ var (
 	counterContract       string = "0x0331034cbde9af8aef62929b5886b096ae3d11e33e6ca23122669e928d406500"
 	someMainnetContract   string = "0x024dE48Fb640DB135B3dc85ef0FE2789e032FbCA2fca54E58aB8dB93ca22F767"
 	address               string = "0x126dd900b82c7fc95e8851f9c64d0600992e82657388a48d3c466553d4d9246"
-	privakeKey            string = "0x879d7dad7f9df54e1474ccf572266bba36d40e3202c799d6c477506647c126"
 	feeMargin             uint64 = 115
 	maxPoll               int    = 100
 	pollInterval          int    = 6
@@ -52,17 +51,24 @@ func getRandomKeys() (*felt.Felt, *felt.Felt) {
 
 // precomputeAddress computes the address by hashing the relevant data.
 // Note: order matters. Also, use ComputeHashOnElements on CallData if it has multiple values.
-func precomputeAddress(CONTRACT_ADDRESS_PREFIX *felt.Felt, deployerAddress *felt.Felt, salt *felt.Felt, classHash *felt.Felt, constructorCalldataHash *felt.Felt) (*felt.Felt, error) {
+// ref: https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/core/os/contract_address/contract_address.py
+func precomputeAddress(deployerAddress *felt.Felt, salt *felt.Felt, classHash *felt.Felt, constructorCalldata []*felt.Felt) (*felt.Felt, error) {
+	CONTRACT_ADDRESS_PREFIX := new(felt.Felt).SetBytes([]byte("STARKNET_CONTRACT_ADDRESS"))
+
+	constructorCalldataBigIntArr, err := utils.FeltArrToBigIntArr(constructorCalldata)
+	constructorCallDataHashInt, _ := starknetgo.Curve.ComputeHashOnElements(*constructorCalldataBigIntArr)
+
 	bigIntArr, err := utils.FeltArrToBigIntArr([]*felt.Felt{
 		CONTRACT_ADDRESS_PREFIX,
 		deployerAddress,
 		salt,
 		classHash,
-		constructorCalldataHash,
 	})
 	if err != nil {
 		return nil, err
 	}
+	*bigIntArr = append(*bigIntArr, constructorCallDataHashInt)
+
 	preBigInt, err := starknetgo.Curve.ComputeHashOnElements(*bigIntArr)
 	if err != nil {
 		return nil, err
@@ -101,19 +107,16 @@ func main() {
 	}
 	clientv02 := rpcv02.NewProvider(c)
 
+	// Precompute address
 	pub, _ := getRandomKeys()
+	constructorCallData := []*felt.Felt{pub}
+	deployerAddress := &felt.Zero
 	classHash, err := utils.HexToFelt(predeployedClassHash)
 	if err != nil {
 		panic(err)
 	}
-	constructorCallData := pub
-	CONTRACT_ADDRESS_PREFIX, err := utils.HexToFelt("0x535441524b4e45545f434f4e54524143545f41444452455353") // Equivalent to 'STARKNET_CONTRACT_ADDRESS'
-	if err != nil {
-		panic(err)
-	}
-	deployerAddress := &felt.Zero
-
-	precomputedAddress, err := precomputeAddress(CONTRACT_ADDRESS_PREFIX, deployerAddress, pub, classHash, constructorCallData)
+	fmt.Println(deployerAddress, pub, classHash, constructorCallData)
+	precomputedAddress, err := precomputeAddress(deployerAddress, pub, classHash, constructorCallData)
 
 	fmt.Println("precomputedAddress:", precomputedAddress)
 
@@ -128,6 +131,20 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
+
+	// print stuff
+	fmt.Println("Precomputed address", precomputedAddress)
+	fmt.Println("pub", pub)
+	fmt.Println(" account.AccountAddress", account.AccountAddress)
+	fmt.Println("classHash", classHash)
+
+	// At this point you need to add funds to the deployed account in order to use it.
+	var input string
+	fmt.Println("The deployed account has to be feeded with ETH to perform transaction.")
+	fmt.Print("When your account has been funded with the faucet, press any key and enter to continue : ")
+	fmt.Scan(&input)
+
+	// Submit transaction to the network
 	fmt.Println("Initialised account with address:", account.AccountAddress)
 	fmt.Println("NOTE: Not using account to deployAccount as that method doesn't exist. Going to use provider for now.")
 
@@ -136,36 +153,23 @@ func main() {
 			Nonce:     &felt.Zero, // Contract accounts start with nonce zero.
 			MaxFee:    new(felt.Felt).SetUint64(1),
 			Type:      rpcv02.TransactionType_DeployAccount,
-			Version:   rpcv02.TransactionV1,                 // ???
-			Signature: []*felt.Felt{&felt.Zero, &felt.Zero}, // ???
+			Version:   rpcv02.TransactionV1,
+			Signature: []*felt.Felt{&felt.Zero, &felt.Zero}, // todo : Should actually sign this?
 		},
 		ClassHash:           classHash,
 		ContractAddressSalt: pub,
-		ConstructorCalldata: []*felt.Felt{constructorCallData},
+		ConstructorCalldata: []*felt.Felt{pub},
 	}
 	fmt.Println("tx:", tx)
-	resp, err := clientv02.AddDeployAccountTransaction(context.Background(), tx)
+	fmt.Println("constructorCallData:", constructorCallData)
+	ctx := context.Background()
+	// NOTE: this is currently unstable due to context cancelling..
+	resp, err := clientv02.AddDeployAccountTransaction(ctx, tx)
 	if err != nil {
 		panic(err)
 	}
-	fmt.Println("AddDeployAccountTransaction response:", resp)
 
-	// // init account handler
-	// ks := starknetgo.NewMemKeystore()
-	// fakeSenderAddress := privakeKey
-	// fakeSenderAddressFelt, err := utils.HexToFelt(fakeSenderAddress)
-	// if err != nil {
-	// 	panic(err)
-	// }
-	// addressFelt, err := utils.HexToFelt(address)
-	// if err != nil {
-	// 	panic(err)
-	// }
-	// ks.Put(fakeSenderAddress, types.SNValToBN(fakeSenderAddress))
-	// account, err := starknetgo.NewGatewayAccount(fakeSenderAddressFelt, addressFelt, ks, gw)
-	// if err != nil {
-	// 	panic(err.Error())
-	// }
+	fmt.Println("AddDeployAccountTransaction response:", resp)
 
 	// increment := []types.FunctionCall{
 	// 	{