Substraction with borrow

[fkrause98]

Changes

• Closes Implement Big UInt Subtraction with Borrow for modexp #133.
• This PR adds a substraction with borrow function for BigUInts (i.e. a-b, where a > b).

How to test

Paste the below snippet into a contract you can call,
my recommendation is to paste it into the Modexp.yul contract
and then run this test: cargo test modexp_tests_98

// Test1: Simple 2 limbs
// First Number:
//  - First Limb: 0x0...0
//  - Second Limb: 0x0...F
// Second Number:
//  - First Limb: 0x0...0
//  - Second Limb: 0x0...A
// [0x0...0, 0x0...F]
// - 
// [0x0...0, 0x0...A]
// ------------------
// [0x0...0, 0x0...5]
// Should print:
// 0 (first limb)
// 5 (second limb)

mstore(0x00, 0x0)
mstore(0x20, 0xF)

mstore(0x40, 0x0)
mstore(0x60, 0xA)

let retStart := 0x80
let _, borrow := bigUintSubstractionWithBorrow(0x00, 0x40, 2, retStart)

let res := mload(retStart)
let res2 := mload(add(retStart, 0x20))
let res3 := mload(add(retStart, 0x40))
let res4 := mload(add(retStart, 0x60))

console_log(res)
console_log(res2)

// Test2: Borrow works as expected
// First Number:
//  - First Limb: 0xFF
//  - Second Limb: 0xAA
// Second Number:
//  - First Limb: 0xAA
//  - Second Limb: 0xFF
// Should print:
// 54 (first limb)
// ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffab (second limb)



mstore(0x00, 0xFF)
mstore(0x20, 0xAA)

mstore(0x40, 0xAA)
mstore(0x60, 0xFF)


let retStart := 0x80
let _, borrow := bigUintSubstractionWithBorrow(0x00, 0x40, 2, retStart)

let res := mload(retStart)
let res2 := mload(add(retStart, 0x20))
let res3 := mload(add(retStart, 0x40))
let res4 := mload(add(retStart, 0x60))

console_log(res)
console_log(res2)

// Test3: Big number 2 limb substraction
// I've tested this againts our reference (Lambdaworks) and gives the same result.
// First Number:
mstore(0x20, 0xffffaaaaaaaaaaaaaaaaffffffffffffffffaaaaaaaaaaaaaaaa)
mstore(0x40, 0xffffffffffffffffaaaaaaaaaaaaaaaaffffffffffffffffaaaaaaaaaaaaaaaa)
// Second Number:
mstore(0x60, 0xaaaaffffffffffffffffaaaaaaaaaaaaaaaaffffffffffffffff)
mstore(0x80, 0xaaaaaaaaaaaaaaaaffffffffffffffffaaaaaaaaaaaaaaaaffffffffffffffff)

let retStart := 0x100
let _, borrow := bigUintSubstractionWithBorrow(0x20, 0x60, 2, retStart)

// Should print:
// 5554aaaaaaaaaaaaaaab5555555555555554aaaaaaaaaaaaaaab
// 5555555555555554aaaaaaaaaaaaaaab5555555555555554aaaaaaaaaaaaaaab            

let res := mload(retStart)
let res2 := mload(add(retStart, 0x20))

console_log(res)
console_log(res2)

[jpcenteno]

I wrote these tests to check this PR:

First, paste this snippet to precompiles/Playground.yul:

object "Playground" {
	code { }
	object "Playground_deployed" {
		code {
            function console_log(val) -> {
                let log_address := 0x000000000000000000636F6e736F6c652e6c6f67
                // A big memory address to store the function selector.
                let freeMemPointer := 0x600
                // store the function selector of log(uint256) in memory
                mstore(freeMemPointer, 0xf82c50f1) // mem[0] = 0xf8...
                // store the first argument of log(uint256) in the next memory slot
                mstore(add(freeMemPointer, 0x20), val)
                // call the console.log contract
                if iszero(staticcall(gas(),log_address,add(freeMemPointer, 28),add(freeMemPointer, 0x40),0x00,0x00)) {
                    revert(0,0)
                }
            }

            // 🤌 PASTE EVERY FUNCTION FROM MODEXP HERE 🤌

            // TESTS

            // lhs = [0]
            // rhs = [0]
            // expected = [0]
            let lhsptr := 0x00
            let rhsptr := 0x20
            let resptr := 0x40
            let numberoflimbs := 1
            mstore(lhsptr, 0x00)
            mstore(rhsptr, 0x00)
            bigUintSubtractionWithBorrow(lhsptr, rhsptr, numberoflimbs, resptr)
            console_log(mload(resptr)) // Should print 0
            

            // lhs = [0xFF]
            // rhs = [0]
            // expected = [0xFF]
            let lhsptr := 0x00
            let rhsptr := 0x20
            let resptr := 0x40
            let numberoflimbs := 1
            mstore(lhsptr, 0xFF)
            mstore(rhsptr, 0x00)
            bigUintSubtractionWithBorrow(lhsptr, rhsptr, numberoflimbs, resptr)
            console_log(sub(mload(resptr), 0xFF) // Should print 0

            // lhs = [0xFF]
            // rhs = [0xF0]
            // expected = [0x0F]
            let lhsptr := 0x00
            let rhsptr := 0x20
            let resptr := 0x40
            let numberoflimbs := 1
            mstore(lhsptr, 0xFF)
            mstore(rhsptr, 0xF0)
            bigUintSubtractionWithBorrow(lhsptr, rhsptr, numberoflimbs, resptr)
            console_log(sub(mload(resptr), 0x0F) // Should print 0

            // 2-limb subtraction without borrow
            // lhs      = [0xAB, 0xCD]
            // rhs      = [0xA0, 0x0D]
            // expected = [0x0B, 0xC0]
            let lhsptr := 0x00
            let rhsptr := 0x40
            let resptr := 0x80
            let numberoflimbs := 2
            mstore(add(lhsptr, 0x00), 0xAB)
            mstore(add(lhsptr, 0x20), 0xCD)
            mstore(add(rhsptr, 0x00), 0xA0)
            mstore(add(rhsptr, 0x20), 0x0D)
            bigUintSubtractionWithBorrow(lhsptr, rhsptr, numberoflimbs, resptr)
            console_log(sub(mload(add(resptr, 0x00)), 0x0B) // Should print 0
            console_log(sub(mload(add(resptr, 0x20)), 0xC0) // Should print 0

            // 2-limb subtraction with borrow
            // lhs      = [0x01, 0x00]
            // rhs      = [0x00, 0x01]
            // expected = [0x00, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff]
            let lhsptr := 0x00
            let rhsptr := 0x40
            let resptr := 0x80
            let numberoflimbs := 2
            mstore(add(lhsptr, 0x00), 0x01)
            mstore(add(lhsptr, 0x20), 0x00)
            mstore(add(rhsptr, 0x00), 0x00)
            mstore(add(rhsptr, 0x20), 0x01)
            bigUintSubtractionWithBorrow(lhsptr, rhsptr, numberoflimbs, resptr)
            console_log(sub(mload(add(resptr, 0x00)), 0x0) // should print 0
            console_log(sub(mload(add(resptr, 0x20)), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // should print 0

            // 4-limb subtraction with borrow
            // lhs      = [0xFFFF, 0xAAAA, 0xFFFF, 0xAAAA]
            // rhs      = [0xAAAA, 0xFFFF, 0xAAAA, 0xFFF]
            // expected = [0x5554, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaaab, 0x5555, 0x9aab]
            let lhsptr := 0x00
            let rhsptr := 0x80
            let resptr := 0x100
            let numberoflimbs := 4

            mstore(add(lhsptr, 0x00), 0xFFFF) // lhs[0] = 0xFFFF
            mstore(add(lhsptr, 0x20), 0xAAAA) // lhs[1] = 0xAAAA
            mstore(add(lhsptr, 0x40), 0xFFFF) // lhs[2] = 0xFFFF
            mstore(add(lhsptr, 0x60), 0xAAAA) // lhs[3] = 0xAAAA

            mstore(add(rhsptr, 0x00), 0xAAAA) // rhs[0] = 0xAAAA
            mstore(add(rhsptr, 0x20), 0xFFFF) // rhs[1] = 0xFFFF
            mstore(add(rhsptr, 0x40), 0xAAAA) // rhs[2] = 0xAAAA
            mstore(add(rhsptr, 0x60), 0xFFF)  // rhs[3] = 0xFFF

            bigUintSubtractionWithBorrow(lhsptr, rhsptr, numberoflimbs, resptr)
            console_log(sub(mload(add(resptr, 0x00)), 0x5554) // res[0], should print 0
            console_log(sub(mload(add(resptr, 0x20)), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaaab) // res[1], should print 0
            console_log(sub(mload(add(resptr, 0x40)), 0x5555) // res[2], should print 0
            console_log(sub(mload(add(resptr, 0x60)), 0x9aab) // res[3], should print 0
            

        }
	}
}

Then, copy all your functions from precompiles/ModExp.yul.

after that, compile the contracts and spin up the era-test-node using make run.

When the server is ready, run the tests using

 zksync-era-cli --host localhost --port 8011 call --contract 0x000000000000000000000000000000000000FFFF --function "" --data 00  --private-key 0x850683b40d4a740aa6e745f889a6fdc8327be76e122f5aba645a5b02d0248db8

The expected output should be:

....
Call SUCCESS
=== Console Logs:
0
0
0
0
0
0
0
0
0
0
0
=== Call traces:
....

If you see a non-zero value, it means that one of the resulting limbs does not equal the expected value.

[ilitteri]

Nice work! Everything looks good, I suggested a little optimization for the main loop.

[jpcenteno]

closes #133