From aa6ee3627a45cd51007bd9afff40d768e4e924d1 Mon Sep 17 00:00:00 2001 From: Gregory Edison Date: Fri, 10 Nov 2023 12:34:10 +0300 Subject: [PATCH] fix based on comments --- pkg/hintrunner/hint.go | 47 +++++++++++++++++++++---------------- pkg/hintrunner/hint_test.go | 15 +++++------- 2 files changed, 33 insertions(+), 29 deletions(-) diff --git a/pkg/hintrunner/hint.go b/pkg/hintrunner/hint.go index 97984da5e..b9d71c721 100644 --- a/pkg/hintrunner/hint.go +++ b/pkg/hintrunner/hint.go @@ -978,27 +978,35 @@ func (hint Uint512DivModByUint256) Execute(vm *VM.VirtualMachine, _ *HintRunnerC return err } + var dividendBytes [64]byte dividend0Bytes := dividend0Felt.Bytes() dividend1Bytes := dividend1Felt.Bytes() dividend2Bytes := dividend2Felt.Bytes() dividend3Bytes := dividend3Felt.Bytes() - low := append(dividend1Bytes[16:], dividend0Bytes[16:]...) - high := append(dividend3Bytes[16:], dividend2Bytes[16:]...) + copy(dividendBytes[:16], dividend3Bytes[16:]) + copy(dividendBytes[16:32], dividend2Bytes[16:]) + copy(dividendBytes[32:48], dividend1Bytes[16:]) + copy(dividendBytes[48:], dividend0Bytes[16:]) + // TODO: check for possible use of uint512 module. dividend := &big.Int{} - dividend.SetBytes(append(high, low...)) + dividend.SetBytes(dividendBytes[:]) + var divisorBytes [32]byte divisor0Bytes := divisor0Felt.Bytes() divisor1Bytes := divisor1Felt.Bytes() + copy(divisorBytes[:16], divisor1Bytes[16:]) + copy(divisorBytes[16:], divisor0Bytes[16:]) + // TODO: check for possible use of uint512 module. divisor := &big.Int{} - divisor.SetBytes(append(divisor1Bytes[16:], divisor0Bytes[16:]...)) + divisor.SetBytes(divisorBytes[:]) if divisor.Cmp(big.NewInt(0)) == 0 { return fmt.Errorf("division by zero") } quotient, rem := dividend.DivMod(dividend, divisor, &big.Int{}) - qBytes := make([]byte, 64) - quotient.FillBytes(qBytes) + var qBytes [64]byte + quotient.FillBytes(qBytes[:]) qlimb3 := f.Element{} qlimb3.SetBytes(qBytes[:16]) qlimb2 := f.Element{} @@ -1008,8 +1016,8 @@ func (hint Uint512DivModByUint256) Execute(vm *VM.VirtualMachine, _ *HintRunnerC qlimb0 := f.Element{} qlimb0.SetBytes(qBytes[48:]) - rBytes := make([]byte, 32) - rem.FillBytes(rBytes) + var rBytes [32]byte + rem.FillBytes(rBytes[:]) rlimb1 := f.Element{} rlimb1.SetBytes(rBytes[:16]) rlimb0 := f.Element{} @@ -1020,35 +1028,35 @@ func (hint Uint512DivModByUint256) Execute(vm *VM.VirtualMachine, _ *HintRunnerC return fmt.Errorf("get destination cell: %v", err) } quotient0Val := mem.MemoryValueFromFieldElement(&qlimb0) - err = vm.Memory.WriteToAddress("ient0Addr, "ient0Val) - if err != nil { + + if err = vm.Memory.WriteToAddress("ient0Addr, "ient0Val); err != nil { return fmt.Errorf("write cell: %v", err) } + quotient1Addr, err := hint.quotient1.Get(vm) if err != nil { return fmt.Errorf("get destination cell: %v", err) } quotient1Val := mem.MemoryValueFromFieldElement(&qlimb1) - err = vm.Memory.WriteToAddress("ient1Addr, "ient1Val) - if err != nil { + if err = vm.Memory.WriteToAddress("ient1Addr, "ient1Val); err != nil { return fmt.Errorf("write cell: %v", err) } + quotient2Addr, err := hint.quotient2.Get(vm) if err != nil { return fmt.Errorf("get destination cell: %v", err) } quotient2Val := mem.MemoryValueFromFieldElement(&qlimb2) - err = vm.Memory.WriteToAddress("ient2Addr, "ient2Val) - if err != nil { + if err = vm.Memory.WriteToAddress("ient2Addr, "ient2Val); err != nil { return fmt.Errorf("write cell: %v", err) } + quotient3Addr, err := hint.quotient3.Get(vm) if err != nil { return fmt.Errorf("get destination cell: %v", err) } quotient3Val := mem.MemoryValueFromFieldElement(&qlimb3) - err = vm.Memory.WriteToAddress("ient3Addr, "ient3Val) - if err != nil { + if err = vm.Memory.WriteToAddress("ient3Addr, "ient3Val); err != nil { return fmt.Errorf("write cell: %v", err) } @@ -1057,17 +1065,16 @@ func (hint Uint512DivModByUint256) Execute(vm *VM.VirtualMachine, _ *HintRunnerC return fmt.Errorf("get destination cell: %v", err) } remainder0Val := mem.MemoryValueFromFieldElement(&rlimb0) - err = vm.Memory.WriteToAddress(&remainder0Addr, &remainder0Val) - if err != nil { + if err = vm.Memory.WriteToAddress(&remainder0Addr, &remainder0Val); err != nil { return fmt.Errorf("write cell: %v", err) } + remainder1Addr, err := hint.remainder1.Get(vm) if err != nil { return fmt.Errorf("get destination cell: %v", err) } remainder1Val := mem.MemoryValueFromFieldElement(&rlimb1) - err = vm.Memory.WriteToAddress(&remainder1Addr, &remainder1Val) - if err != nil { + if err = vm.Memory.WriteToAddress(&remainder1Addr, &remainder1Val); err != nil { return fmt.Errorf("write cell: %v", err) } return nil diff --git a/pkg/hintrunner/hint_test.go b/pkg/hintrunner/hint_test.go index 802183f7a..d20ee53e4 100644 --- a/pkg/hintrunner/hint_test.go +++ b/pkg/hintrunner/hint_test.go @@ -551,9 +551,8 @@ func TestUint512DivModByUint256(t *testing.T) { require.Nil(t, err) quotient0 := &f.Element{} - val, ok := big.NewInt(1).SetString("170141183460469231731687303715884105730", 10) - require.True(t, ok) - quotient0.SetBigInt(val) + _, err = quotient0.SetString("170141183460469231731687303715884105730") + require.Nil(t, err) require.Equal( t, @@ -562,9 +561,8 @@ func TestUint512DivModByUint256(t *testing.T) { ) quotient1 := &f.Element{} - val, ok = big.NewInt(1).SetString("662027951208051485337304683719393406", 10) - require.True(t, ok) - quotient1.SetBigInt(val) + _, err = quotient1.SetString("662027951208051485337304683719393406") + require.Nil(t, err) require.Equal( t, @@ -591,9 +589,8 @@ func TestUint512DivModByUint256(t *testing.T) { ) remainder0 := &f.Element{} - val, ok = big.NewInt(1).SetString("340282366920938463463374607431768210942", 10) - require.True(t, ok) - remainder0.SetBigInt(val) + _, err = remainder0.SetString("340282366920938463463374607431768210942") + require.Nil(t, err) require.Equal( t,