From 30ea36ed9ca7e21d2519755c6a21ad42dc2b923d Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Wed, 30 Nov 2022 13:48:59 +0100 Subject: [PATCH 1/8] feat Add starkshell feltcode for multiplication --- src/starkshell/mul.cairo | 63 +++++++++++++++++++ .../printInterpreteInstruction.cairo | 24 +++++++ src/starkshell/printMul.cairo | 22 +++++++ 3 files changed, 109 insertions(+) create mode 100644 src/starkshell/mul.cairo create mode 100644 src/starkshell/printInterpreteInstruction.cairo create mode 100644 src/starkshell/printMul.cairo diff --git a/src/starkshell/mul.cairo b/src/starkshell/mul.cairo new file mode 100644 index 0000000..795aacc --- /dev/null +++ b/src/starkshell/mul.cairo @@ -0,0 +1,63 @@ +from starkware.cairo.common.alloc import alloc +from starkware.cairo.common.bool import FALSE, TRUE + +from src.zkode.facets.starkshell.structs import Primitive, Variable, Instruction + +func mul() -> (res_len: felt, res: felt*) { + alloc_locals; + + local return_keyword; + local mul_keyword; + local calldata_id; + local mulvar_id; + local starkshell_hash; + + %{ + from starkware.starknet.public.abi import get_selector_from_name + ids.return_keyword = get_selector_from_name("__ZKLANG__RETURN") + ids.mul_keyword = get_selector_from_name("__ZKLANG__MUL") + ids.calldata_id = get_selector_from_name("__ZKLANG__CALLDATA_VAR") + ids.mulvar_id = get_selector_from_name("my_res_variable") + + import os + ids.starkshell_hash = int(os.getenv("STARKSHELL_HASH"), 16) + %} + + tempvar NULLvar = Variable(0, 0, 0, 0); + tempvar Calldata = Variable(calldata_id, 0, 0, 0); + tempvar mulvar = Variable(mulvar_id, 0, 0, 0); + + tempvar instruction0 = Instruction( + primitive=Primitive(starkshell_hash, mul_keyword), + input1=Calldata, + input2=NULLvar, + output=mulvar, + ); + + tempvar instruction1 = Instruction( + primitive=Primitive(starkshell_hash, return_keyword), + input1=mulvar, + input2=NULLvar, + output=NULLvar, + ); + + tempvar Calldata = Variable(calldata_id, 0, 0, 2); + tempvar program = new (instruction0, instruction1); + tempvar memory = (Calldata, 4, 3, mulvar); + + local program_len = 2 * Instruction.SIZE; + local memory_len = 2 * Variable.SIZE + Calldata.data_len; + + let total_len = program_len + memory_len + 1; + let felt_code_len = total_len + 1; + + tempvar felt_code: felt* = new ( + program_len, + instruction0, + instruction1, + memory_len, + memory, + ); + + return (felt_code_len, felt_code); +} diff --git a/src/starkshell/printInterpreteInstruction.cairo b/src/starkshell/printInterpreteInstruction.cairo new file mode 100644 index 0000000..255f09b --- /dev/null +++ b/src/starkshell/printInterpreteInstruction.cairo @@ -0,0 +1,24 @@ +%builtins output +from starkware.cairo.common.alloc import alloc +from starkware.cairo.common.serialize import serialize_word + +from src.starkshell.interpreteInstruction import interpreteInstruction + +func main{output_ptr: felt*}() { + alloc_locals; + + let (felt_code_len, felt_code) = interpreteInstruction(); + print(felt_code_len, felt_code); + + return (); +} + +func print{output_ptr: felt*}(felt_code_len: felt, felt_code: felt*) { + if (felt_code_len == 0) { + return (); + } + + serialize_word(felt_code[0]); + + return print(felt_code_len - 1, felt_code + 1); +} diff --git a/src/starkshell/printMul.cairo b/src/starkshell/printMul.cairo new file mode 100644 index 0000000..9c689a4 --- /dev/null +++ b/src/starkshell/printMul.cairo @@ -0,0 +1,22 @@ +%builtins output +from starkware.cairo.common.serialize import serialize_word + +from src.starkshell.mul import mul + +func main{output_ptr: felt*}() { + // Replace with required function + let (felt_code_len, felt_code) = mul(); + print(felt_code_len, felt_code); + + return (); +} + +func print{output_ptr: felt*}(felt_code_len: felt, felt_code: felt*) { + if (felt_code_len == 0) { + return (); + } + + serialize_word(felt_code[0]); + + return print(felt_code_len - 1, felt_code + 1); +} From 6b642922dfb13827413facb752f218279f3d0150 Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Wed, 30 Nov 2022 20:59:03 +0100 Subject: [PATCH 2/8] feat Return memory and result by emitting events --- src/zkode/facets/starkshell/StarkShell.cairo | 27 +++++++- tests/starkshell/test_starkshell.cairo | 73 ++++++++++++++++++-- 2 files changed, 90 insertions(+), 10 deletions(-) diff --git a/src/zkode/facets/starkshell/StarkShell.cairo b/src/zkode/facets/starkshell/StarkShell.cairo index 941215e..5135b8c 100644 --- a/src/zkode/facets/starkshell/StarkShell.cairo +++ b/src/zkode/facets/starkshell/StarkShell.cairo @@ -26,6 +26,14 @@ from src.zkode.facets.starkshell.primitives.core import ( __ZKLANG__DIV, ) +@event +func InterpreterMemory(mem_len: felt, mem: felt*) { +} + +@event +func InterpreterResult(res_len: felt, res: felt*) { +} + @external @raw_input @raw_output @@ -175,12 +183,14 @@ func exec_loop{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}( } } +// @param _debug: bool flag for emit memory @external func __ZKLANG__EXEC{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}( - _program_len: felt, _program: felt*, _memory_len: felt, _memory: felt* + _debug: felt, _program_len: felt, _program: felt*, _memory_len: felt, _memory: felt* ) -> (res_len: felt, res: felt*) { - // TODO return state - let (res_len, res, _, _) = exec_loop( + alloc_locals; + + let (res_len, res, memory_len, memory) = exec_loop( _pc=0, _program_len=_program_len, _program=_program, @@ -188,6 +198,17 @@ func __ZKLANG__EXEC{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ _memory=_memory, ); + if (_debug == TRUE) { + InterpreterMemory.emit(memory_len, memory); + tempvar syscall_ptr = syscall_ptr; + tempvar range_check_ptr = range_check_ptr; + } else { + tempvar syscall_ptr = syscall_ptr; + tempvar range_check_ptr = range_check_ptr; + } + + InterpreterResult.emit(res_len, res); + return (res_len, res); } diff --git a/tests/starkshell/test_starkshell.cairo b/tests/starkshell/test_starkshell.cairo index 82a9524..8a5cf0e 100644 --- a/tests/starkshell/test_starkshell.cairo +++ b/tests/starkshell/test_starkshell.cairo @@ -177,7 +177,7 @@ namespace ITestShellFun { } func interpreteInstruction( - _program_len: felt, _program: felt*, _memory_len: felt, _memory: felt* + _debug: felt, _program_len: felt, _program: felt*, _memory_len: felt, _memory: felt* ) -> (res_len: felt, res: felt*) { } } @@ -282,7 +282,9 @@ func test_interpreteInstruction_reverts_if_caller_not_owner{ %{ stop_prank = start_prank(ids.User2, context.diamond_address) %} %{ expect_revert(error_message="NOT AUTHORIZED") %} - ITestShellFun.interpreteInstruction(diamond_address, program_len, program, memory_len, memory); + ITestShellFun.interpreteInstruction( + diamond_address, FALSE, program_len, program, memory_len, memory + ); %{ stop_prank() %} return (); @@ -325,7 +327,7 @@ func test_interpreteInstruction_returnCalldata{ %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, program_len, program, memory_len, memory + diamond_address, FALSE, program_len, program, memory_len, memory ); %{ stop_prank() %} assert_eq(res_len, 2); @@ -384,7 +386,7 @@ func test_interpreteInstruction_add{ %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, program_len, program, memory_len, memory + diamond_address, FALSE, program_len, program, memory_len, memory ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -442,7 +444,7 @@ func test_interpreteInstruction_sub{ %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, program_len, program, memory_len, memory + diamond_address, FALSE, program_len, program, memory_len, memory ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -500,7 +502,7 @@ func test_interpreteInstruction_mul{ %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, program_len, program, memory_len, memory + diamond_address, FALSE, program_len, program, memory_len, memory ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -558,7 +560,7 @@ func test_interpreteInstruction_div{ %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, program_len, program, memory_len, memory + diamond_address, FALSE, program_len, program, memory_len, memory ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -566,3 +568,60 @@ func test_interpreteInstruction_div{ return (); } + +@external +func test_interpreteInstruction_emit_events_on_div{ + syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr +}() -> () { + alloc_locals; + local diamond_address; + %{ ids.diamond_address = context.diamond_address %} + let ch: ClassHash = getClassHashes(); + + local return_keyword; + local div_keyword; + local calldata_id; + local divvar_id; + + %{ + from starkware.starknet.public.abi import get_selector_from_name + ids.return_keyword = get_selector_from_name("__ZKLANG__RETURN") + ids.div_keyword = get_selector_from_name("__ZKLANG__DIV") + ids.calldata_id = get_selector_from_name("__ZKLANG__CALLDATA_VAR") + ids.divvar_id = get_selector_from_name("my_res_variable") + %} + + tempvar NULLvar = Variable(0, 0, 0, 0); + tempvar Calldata = Variable(calldata_id, 0, 0, 0); + tempvar divvar = Variable(divvar_id, 0, 0, 0); + + tempvar instruction0 = Instruction( + primitive=Primitive(ch.starkshell, div_keyword), + input1=Calldata, + input2=NULLvar, + output=divvar, + ); + + tempvar instruction1 = Instruction( + primitive=Primitive(ch.starkshell, return_keyword), + input1=divvar, + input2=NULLvar, + output=NULLvar, + ); + + tempvar Calldata = Variable(calldata_id, 0, 0, 2); + tempvar program = new (instruction0, instruction1); + tempvar memory = new (Calldata, 8, 2, divvar); + + local program_len = 2 * Instruction.SIZE; + local memory_len = 2 * Variable.SIZE + Calldata.data_len; + + %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} + %{ expect_events({"name": "InterpreterMemory", "data": [11, ids.calldata_id, 0, 0, 2, 8, 2, ids.divvar_id, 0, 0, 1, 4]}, {"name": "InterpreterResult", "data": [1, 4]}) %} + ITestShellFun.interpreteInstruction( + diamond_address, TRUE, program_len, program, memory_len, memory + ); + %{ stop_prank() %} + + return (); +} From 75040292aba76f83b9efca6fc477b1b38a0b9710 Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Thu, 1 Dec 2022 13:08:50 +0100 Subject: [PATCH 3/8] feat: Add calldata params to exec primitive --- src/starkshell/mul.cairo | 37 +++--- src/starkshell/printMul.cairo | 2 +- src/zkode/facets/starkshell/StarkShell.cairo | 24 +++- tests/starkshell/test_starkshell.cairo | 117 ++++++++++++++----- 4 files changed, 133 insertions(+), 47 deletions(-) diff --git a/src/starkshell/mul.cairo b/src/starkshell/mul.cairo index 795aacc..ac2d49b 100644 --- a/src/starkshell/mul.cairo +++ b/src/starkshell/mul.cairo @@ -1,9 +1,10 @@ from starkware.cairo.common.alloc import alloc from starkware.cairo.common.bool import FALSE, TRUE +from starkware.cairo.common.memcpy import memcpy from src.zkode.facets.starkshell.structs import Primitive, Variable, Instruction -func mul() -> (res_len: felt, res: felt*) { +func mul(_x: felt, _y: felt) -> (res_len: felt, res: felt*) { alloc_locals; local return_keyword; @@ -41,23 +42,31 @@ func mul() -> (res_len: felt, res: felt*) { output=NULLvar, ); - tempvar Calldata = Variable(calldata_id, 0, 0, 2); tempvar program = new (instruction0, instruction1); - tempvar memory = (Calldata, 4, 3, mulvar); + tempvar memory = new (mulvar); + tempvar calldata = new (_x, _y); local program_len = 2 * Instruction.SIZE; - local memory_len = 2 * Variable.SIZE + Calldata.data_len; + local memory_len = 1 * Variable.SIZE; + local calldata_len = 2; - let total_len = program_len + memory_len + 1; - let felt_code_len = total_len + 1; - - tempvar felt_code: felt* = new ( - program_len, - instruction0, - instruction1, - memory_len, - memory, - ); + let (local felt_code: felt*) = alloc(); + let felt_code_len = 0; + let felt_code_len = append(felt_code_len, felt_code, program_len, program); + let felt_code_len = append(felt_code_len, felt_code, memory_len, memory); + let felt_code_len = append(felt_code_len, felt_code, calldata_len, calldata); return (felt_code_len, felt_code); } + +// @dev Append _array to _ptr +// @return New length of _ptr +func append(_ptr_len: felt, _ptr: felt*, _array_len: felt, _array: felt*) -> felt { + assert _ptr[_ptr_len] = _array_len; + let _ptr_len = _ptr_len + 1; + + memcpy(_ptr + _ptr_len, _array, _array_len); + let _ptr_len = _ptr_len + _array_len; + + return _ptr_len; +} diff --git a/src/starkshell/printMul.cairo b/src/starkshell/printMul.cairo index 9c689a4..4bd6ab8 100644 --- a/src/starkshell/printMul.cairo +++ b/src/starkshell/printMul.cairo @@ -5,7 +5,7 @@ from src.starkshell.mul import mul func main{output_ptr: felt*}() { // Replace with required function - let (felt_code_len, felt_code) = mul(); + let (felt_code_len, felt_code) = mul(4, 3); print(felt_code_len, felt_code); return (); diff --git a/src/zkode/facets/starkshell/StarkShell.cairo b/src/zkode/facets/starkshell/StarkShell.cairo index 5135b8c..12ce0e7 100644 --- a/src/zkode/facets/starkshell/StarkShell.cairo +++ b/src/zkode/facets/starkshell/StarkShell.cairo @@ -186,16 +186,30 @@ func exec_loop{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}( // @param _debug: bool flag for emit memory @external func __ZKLANG__EXEC{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}( - _debug: felt, _program_len: felt, _program: felt*, _memory_len: felt, _memory: felt* + _debug: felt, + _program_len: felt, + _program: felt*, + _memory_len: felt, + _memory: felt*, + _calldata_len: felt, + _calldata: felt*, ) -> (res_len: felt, res: felt*) { alloc_locals; + // TODO prepare program (i.e. replace zero class hashes with this class hash) + // let (prep_program_len, prep_program) = Program.prepare(selector, _program_len, _program); + local prep_program_len: felt = _program_len; + local prep_program: felt* = _program; + let (prep_memory_len, prep_memory) = Memory.init( + _memory_len, _memory, _calldata_len, _calldata + ); + let (res_len, res, memory_len, memory) = exec_loop( _pc=0, - _program_len=_program_len, - _program=_program, - _memory_len=_memory_len, - _memory=_memory, + _program_len=prep_program_len, + _program=prep_program, + _memory_len=prep_memory_len, + _memory=prep_memory, ); if (_debug == TRUE) { diff --git a/tests/starkshell/test_starkshell.cairo b/tests/starkshell/test_starkshell.cairo index 8a5cf0e..8954898 100644 --- a/tests/starkshell/test_starkshell.cairo +++ b/tests/starkshell/test_starkshell.cairo @@ -177,7 +177,13 @@ namespace ITestShellFun { } func interpreteInstruction( - _debug: felt, _program_len: felt, _program: felt*, _memory_len: felt, _memory: felt* + _debug: felt, + _program_len: felt, + _program: felt*, + _memory_len: felt, + _memory: felt*, + _calldata_len: felt, + _calldata: felt*, ) -> (res_len: felt, res: felt*) { } } @@ -276,14 +282,23 @@ func test_interpreteInstruction_reverts_if_caller_not_owner{ tempvar program = new (); tempvar memory = new (); + tempvar calldata = new (); local program_len = 0; local memory_len = 0; + local calldata_len = 0; %{ stop_prank = start_prank(ids.User2, context.diamond_address) %} %{ expect_revert(error_message="NOT AUTHORIZED") %} ITestShellFun.interpreteInstruction( - diamond_address, FALSE, program_len, program, memory_len, memory + diamond_address, + _debug=FALSE, + _program_len=program_len, + _program=program, + _memory_len=memory_len, + _memory=memory, + _calldata_len=calldata_len, + _calldata=calldata, ); %{ stop_prank() %} @@ -318,16 +333,24 @@ func test_interpreteInstruction_returnCalldata{ output=NULLvar, ); - tempvar Calldata = Variable(calldata_id, 0, 0, 2); tempvar program = new (instruction0); - tempvar memory = new (Calldata, 3, 4); + tempvar memory = new (); + tempvar calldata = new (3, 4); local program_len = 1 * Instruction.SIZE; - local memory_len = 1 * Variable.SIZE + Calldata.data_len; + local memory_len = 0; + local calldata_len = 2; %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, FALSE, program_len, program, memory_len, memory + diamond_address, + _debug=FALSE, + _program_len=program_len, + _program=program, + _memory_len=memory_len, + _memory=memory, + _calldata_len=calldata_len, + _calldata=calldata, ); %{ stop_prank() %} assert_eq(res_len, 2); @@ -377,16 +400,24 @@ func test_interpreteInstruction_add{ output=NULLvar, ); - tempvar Calldata = Variable(calldata_id, 0, 0, 2); tempvar program = new (instruction0, instruction1); - tempvar memory = new (Calldata, 3, 4, sumvar); + tempvar memory = new (sumvar); + tempvar calldata = new (3, 4); local program_len = 2 * Instruction.SIZE; - local memory_len = 2 * Variable.SIZE + Calldata.data_len; + local memory_len = 1 * Variable.SIZE; + local calldata_len = 2; %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, FALSE, program_len, program, memory_len, memory + diamond_address, + _debug=FALSE, + _program_len=program_len, + _program=program, + _memory_len=memory_len, + _memory=memory, + _calldata_len=calldata_len, + _calldata=calldata, ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -435,16 +466,24 @@ func test_interpreteInstruction_sub{ output=NULLvar, ); - tempvar Calldata = Variable(calldata_id, 0, 0, 2); tempvar program = new (instruction0, instruction1); - tempvar memory = new (Calldata, 4, 3, subvar); + tempvar memory = new (subvar); + tempvar calldata = new (4, 3); local program_len = 2 * Instruction.SIZE; - local memory_len = 2 * Variable.SIZE + Calldata.data_len; + local memory_len = 1 * Variable.SIZE; + local calldata_len = 2; %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, FALSE, program_len, program, memory_len, memory + diamond_address, + _debug=FALSE, + _program_len=program_len, + _program=program, + _memory_len=memory_len, + _memory=memory, + _calldata_len=calldata_len, + _calldata=calldata, ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -493,16 +532,24 @@ func test_interpreteInstruction_mul{ output=NULLvar, ); - tempvar Calldata = Variable(calldata_id, 0, 0, 2); tempvar program = new (instruction0, instruction1); - tempvar memory = new (Calldata, 4, 3, mulvar); + tempvar memory = new (mulvar); + tempvar calldata = new (4, 3); local program_len = 2 * Instruction.SIZE; - local memory_len = 2 * Variable.SIZE + Calldata.data_len; + local memory_len = 1 * Variable.SIZE; + local calldata_len = 2; %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, FALSE, program_len, program, memory_len, memory + diamond_address, + _debug=FALSE, + _program_len=program_len, + _program=program, + _memory_len=memory_len, + _memory=memory, + _calldata_len=calldata_len, + _calldata=calldata, ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -551,16 +598,24 @@ func test_interpreteInstruction_div{ output=NULLvar, ); - tempvar Calldata = Variable(calldata_id, 0, 0, 2); tempvar program = new (instruction0, instruction1); - tempvar memory = new (Calldata, 8, 2, divvar); + tempvar memory = new (divvar); + tempvar calldata = new (8, 2); local program_len = 2 * Instruction.SIZE; - local memory_len = 2 * Variable.SIZE + Calldata.data_len; + local memory_len = 1 * Variable.SIZE; + local calldata_len = 2; %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} let (res_len, res) = ITestShellFun.interpreteInstruction( - diamond_address, FALSE, program_len, program, memory_len, memory + diamond_address, + _debug=FALSE, + _program_len=program_len, + _program=program, + _memory_len=memory_len, + _memory=memory, + _calldata_len=calldata_len, + _calldata=calldata, ); %{ stop_prank() %} assert_eq(res_len, 1); @@ -609,17 +664,25 @@ func test_interpreteInstruction_emit_events_on_div{ output=NULLvar, ); - tempvar Calldata = Variable(calldata_id, 0, 0, 2); tempvar program = new (instruction0, instruction1); - tempvar memory = new (Calldata, 8, 2, divvar); + tempvar memory = new (divvar); + tempvar calldata = new (8, 2); local program_len = 2 * Instruction.SIZE; - local memory_len = 2 * Variable.SIZE + Calldata.data_len; + local memory_len = 1 * Variable.SIZE; + local calldata_len = 2; %{ stop_prank = start_prank(ids.User1, context.diamond_address) %} - %{ expect_events({"name": "InterpreterMemory", "data": [11, ids.calldata_id, 0, 0, 2, 8, 2, ids.divvar_id, 0, 0, 1, 4]}, {"name": "InterpreterResult", "data": [1, 4]}) %} + %{ expect_events({"name": "InterpreterResult", "data": [1, 4]}) %} ITestShellFun.interpreteInstruction( - diamond_address, TRUE, program_len, program, memory_len, memory + diamond_address, + _debug=TRUE, + _program_len=program_len, + _program=program, + _memory_len=memory_len, + _memory=memory, + _calldata_len=calldata_len, + _calldata=calldata, ); %{ stop_prank() %} From 511c8e1c2ec2a0d50fe4159ccf0fe8827ee5afd2 Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Thu, 1 Dec 2022 13:47:56 +0100 Subject: [PATCH 4/8] refactor Move table function into common --- src/common/table.cairo | 14 +++++ src/starkshell/mul.cairo | 20 ++----- tests/common/test_table.cairo | 102 ++++++++++++++++++++++++++++++++++ 3 files changed, 120 insertions(+), 16 deletions(-) create mode 100644 src/common/table.cairo create mode 100644 tests/common/test_table.cairo diff --git a/src/common/table.cairo b/src/common/table.cairo new file mode 100644 index 0000000..90c4cdb --- /dev/null +++ b/src/common/table.cairo @@ -0,0 +1,14 @@ +from starkware.cairo.common.memcpy import memcpy + +namespace Table { + // @return New length of _table + func add_row(_table_len: felt, _table: felt*, _row_len: felt, _row: felt*) -> felt { + assert _table[_table_len] = _row_len; + let _table_len = _table_len + 1; + + memcpy(_table + _table_len, _row, _row_len); + let _table_len = _table_len + _row_len; + + return _table_len; + } +} diff --git a/src/starkshell/mul.cairo b/src/starkshell/mul.cairo index ac2d49b..49aec3f 100644 --- a/src/starkshell/mul.cairo +++ b/src/starkshell/mul.cairo @@ -1,7 +1,7 @@ from starkware.cairo.common.alloc import alloc from starkware.cairo.common.bool import FALSE, TRUE -from starkware.cairo.common.memcpy import memcpy +from src.common.table import Table from src.zkode.facets.starkshell.structs import Primitive, Variable, Instruction func mul(_x: felt, _y: felt) -> (res_len: felt, res: felt*) { @@ -52,21 +52,9 @@ func mul(_x: felt, _y: felt) -> (res_len: felt, res: felt*) { let (local felt_code: felt*) = alloc(); let felt_code_len = 0; - let felt_code_len = append(felt_code_len, felt_code, program_len, program); - let felt_code_len = append(felt_code_len, felt_code, memory_len, memory); - let felt_code_len = append(felt_code_len, felt_code, calldata_len, calldata); + let felt_code_len = Table.add_row(felt_code_len, felt_code, program_len, program); + let felt_code_len = Table.add_row(felt_code_len, felt_code, memory_len, memory); + let felt_code_len = Table.add_row(felt_code_len, felt_code, calldata_len, calldata); return (felt_code_len, felt_code); } - -// @dev Append _array to _ptr -// @return New length of _ptr -func append(_ptr_len: felt, _ptr: felt*, _array_len: felt, _array: felt*) -> felt { - assert _ptr[_ptr_len] = _array_len; - let _ptr_len = _ptr_len + 1; - - memcpy(_ptr + _ptr_len, _array, _array_len); - let _ptr_len = _ptr_len + _array_len; - - return _ptr_len; -} diff --git a/tests/common/test_table.cairo b/tests/common/test_table.cairo new file mode 100644 index 0000000..41f6cac --- /dev/null +++ b/tests/common/test_table.cairo @@ -0,0 +1,102 @@ +%lang starknet +from starkware.cairo.common.alloc import alloc + +from src.common.table import Table + +from protostar.asserts import assert_eq + +@external +func test_append_empty_array_to_empty_array() { + alloc_locals; + + let (local table: felt*) = alloc(); + let (local row: felt*) = alloc(); + + local table_len = 0; + local row_len = 0; + + let table_len = Table.add_row(table_len, table, row_len, row); + + assert_eq(table_len, 1); + assert_eq(table[0], 0); + + return (); +} + +@external +func test_append_empty_array_to_non_empty_array() { + alloc_locals; + + let (local table: felt*) = alloc(); + let (local row: felt*) = alloc(); + + assert table[0] = 2; + assert table[1] = 11; + assert table[2] = 12; + + local table_len = 3; + local row_len = 0; + + let table_len = Table.add_row(table_len, table, row_len, row); + + assert_eq(table_len, 4); + assert_eq(table[0], 2); + assert_eq(table[1], 11); + assert_eq(table[2], 12); + assert_eq(table[3], 0); + + return (); +} + +@external +func test_append_non_empty_array_to_empty_array() { + alloc_locals; + + let (local table: felt*) = alloc(); + let (local row: felt*) = alloc(); + + assert row[0] = 11; + assert row[1] = 12; + assert row[2] = 13; + + local table_len = 0; + local row_len = 3; + + let table_len = Table.add_row(table_len, table, row_len, row); + + assert_eq(table_len, 4); + assert_eq(table[0], 3); + assert_eq(table[1], 11); + assert_eq(table[2], 12); + assert_eq(table[3], 13); + + return (); +} + +@external +func test_append_non_empty_array_to_non_empty_array() { + alloc_locals; + + let (local table: felt*) = alloc(); + let (local row: felt*) = alloc(); + + assert table[0] = 0; + + assert row[0] = 11; + assert row[1] = 12; + assert row[2] = 13; + + local table_len = 1; + local row_len = 3; + + let table_len = Table.add_row(table_len, table, row_len, row); + + assert_eq(table_len, 5); + assert_eq(table[0], 0); + assert_eq(table[1], 3); + assert_eq(table[2], 11); + assert_eq(table[3], 12); + assert_eq(table[4], 13); + + return (); +} From 22e43d147dd31c54095d0cfae8665fb9ec42697b Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Fri, 2 Dec 2022 16:45:33 +0100 Subject: [PATCH 5/8] refcator: Purify Program.prepare() --- src/zkode/facets/starkshell/StarkShell.cairo | 11 +- src/zkode/facets/starkshell/library.cairo | 12 +- tests/starkshell/test_program.cairo | 195 +++++++++++++++++++ 3 files changed, 208 insertions(+), 10 deletions(-) diff --git a/src/zkode/facets/starkshell/StarkShell.cairo b/src/zkode/facets/starkshell/StarkShell.cairo index 12ce0e7..5543faf 100644 --- a/src/zkode/facets/starkshell/StarkShell.cairo +++ b/src/zkode/facets/starkshell/StarkShell.cairo @@ -6,6 +6,7 @@ from starkware.cairo.common.registers import get_label_location from starkware.starknet.common.syscalls import get_contract_address from src.zkode.constants import API +from src.zkode.diamond.IDiamond import IDiamond from src.zkode.diamond.library import Library from src.zkode.facets.storage.flobdb.IFlobDB import IFlobDB from src.zkode.facets.starkshell.library import Program, Memory, State @@ -41,11 +42,13 @@ func __default__{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr selector: felt, calldata_size: felt, calldata: felt* ) -> (retdata_size: felt, retdata: felt*) { alloc_locals; + let fun: Function = State.get_fun(selector); + let (local self: felt) = get_contract_address(); + let (local this_starkshell_hash: felt) = IDiamond.facetAddress(self, selector); // if repo is 0 assume that this contract holds the code - let (self) = get_contract_address(); - let normalized_repo_address = Library._if_x_is_zero_then_y_else_x(fun.repo_address, self); + local normalized_repo_address: felt = Library._if_x_is_zero_then_y_else_x(fun.repo_address, self); with_attr error_message("LOADING CODE FAILED") { let (program_raw_len, program_raw) = IFlobDB.load( @@ -60,7 +63,9 @@ func __default__{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr local memory: felt* = program_raw + 1 + program_len; // init - let (prep_program_len, prep_program) = Program.prepare(selector, program_len, program); + let (prep_program_len, prep_program) = Program.prepare( + this_starkshell_hash, program_len, program + ); let (prep_memory_len, prep_memory) = Memory.init(memory_len, memory, calldata_size, calldata); with_attr error_message("EXEC INSTRUCTION 0") { diff --git a/src/zkode/facets/starkshell/library.cairo b/src/zkode/facets/starkshell/library.cairo index 60c41c0..9caece5 100644 --- a/src/zkode/facets/starkshell/library.cairo +++ b/src/zkode/facets/starkshell/library.cairo @@ -11,7 +11,6 @@ from starkware.starknet.common.syscalls import ( ) from src.zkode.constants import API -from src.zkode.diamond.IDiamond import IDiamond from src.zkode.diamond.library import Library from src.zkode.facets.starkshell.structs import ( DataTypes, @@ -65,19 +64,18 @@ namespace Program { } func prepare{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}( - _selector: felt, _program_raw_len: felt, _program_raw: felt* + _this_starkshell_hash: felt, _program_raw_len: felt, _program_raw: felt* ) -> (program_len: felt, program: felt*) { alloc_locals; - // validate(_program_raw[0], _program_raw + 1); - validate(_program_raw_len, _program_raw); - let (this_diamond) = get_contract_address(); - let (this_zklang) = IDiamond.facetAddress(this_diamond, _selector); + validate(_program_raw_len, _program_raw); let (local program: felt*) = alloc(); let program_len = _program_raw_len; - replace_zero_class_hashes_with_self(program, this_zklang, _program_raw_len, _program_raw); + replace_zero_class_hashes_with_self( + program, _this_starkshell_hash, _program_raw_len, _program_raw + ); return (program_len, program); } diff --git a/tests/starkshell/test_program.cairo b/tests/starkshell/test_program.cairo index 9af44f3..50b4401 100644 --- a/tests/starkshell/test_program.cairo +++ b/tests/starkshell/test_program.cairo @@ -353,3 +353,198 @@ func test_replace_zero_class_hashes_with_self{ return (); } + +@external +func test_prepare_reverts_on_non_boolean_protected{ + syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr +}() { + alloc_locals; + + local starkshell_hash = 0x1234567890; + let (local program: felt*) = alloc(); + let program_len = 5 * Instruction.SIZE; + + tempvar instruction_0 = new Instruction( + Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), + ); + tempvar instruction_1 = new Instruction( + Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), + ); + tempvar instruction_2 = new Instruction( + Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 3, 0, 0), + ); + tempvar instruction_3 = new Instruction( + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), + ); + tempvar instruction_4 = new Instruction( + Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), + ); + + memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); + memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); + memcpy(program + 2 * Instruction.SIZE, instruction_2, Instruction.SIZE); + memcpy(program + 3 * Instruction.SIZE, instruction_3, Instruction.SIZE); + memcpy(program + 4 * Instruction.SIZE, instruction_4, Instruction.SIZE); + + %{ expect_revert(error_message="CORRUPT CODE") %} + Program.prepare(starkshell_hash, program_len, program); + + return (); +} + +@external +func test_prepare_reverts_on_unknown_type_key{ + syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr +}() { + alloc_locals; + + local starkshell_hash = 0x1234567890; + let (local program: felt*) = alloc(); + let program_len = 5 * Instruction.SIZE; + + tempvar instruction_0 = new Instruction( + Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), + ); + tempvar instruction_1 = new Instruction( + Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), + ); + tempvar instruction_2 = new Instruction( + Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 3, 0), + ); + tempvar instruction_3 = new Instruction( + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), + ); + tempvar instruction_4 = new Instruction( + Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), + ); + + memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); + memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); + memcpy(program + 2 * Instruction.SIZE, instruction_2, Instruction.SIZE); + memcpy(program + 3 * Instruction.SIZE, instruction_3, Instruction.SIZE); + memcpy(program + 4 * Instruction.SIZE, instruction_4, Instruction.SIZE); + + %{ expect_revert(error_message="CORRUPT CODE") %} + Program.prepare(starkshell_hash, program_len, program); + + return (); +} + +@external +func test_prepare_replaces_zero_class_hash_with_starkshell_hash{ + syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr +}() { + alloc_locals; + + local starkshell_hash = 0x1234567890; + let (local program: felt*) = alloc(); + let program_len = 5 * Instruction.SIZE; + + tempvar instruction_0 = new Instruction( + Primitive(0, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), + ); + tempvar instruction_1 = new Instruction( + Primitive(0, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), + ); + tempvar instruction_2 = new Instruction( + Primitive(1, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 1, 0), + ); + tempvar instruction_3 = new Instruction( + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), + ); + tempvar instruction_4 = new Instruction( + Primitive(0, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), + ); + + memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); + memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); + memcpy(program + 2 * Instruction.SIZE, instruction_2, Instruction.SIZE); + memcpy(program + 3 * Instruction.SIZE, instruction_3, Instruction.SIZE); + memcpy(program + 4 * Instruction.SIZE, instruction_4, Instruction.SIZE); + + let (actual_program_len, actual_program) = Program.prepare( + starkshell_hash, program_len, program + ); + + let actual_instruction = Program.get_instruction(0, actual_program_len, actual_program); + assert_eq(actual_instruction.primitive.class_hash, starkshell_hash); + assert_eq(actual_instruction.primitive.selector, instruction_0.primitive.selector); + assert_eq(actual_instruction.input1.selector, instruction_0.input1.selector); + assert_eq(actual_instruction.input1.protected, instruction_0.input1.protected); + assert_eq(actual_instruction.input1.type, instruction_0.input1.type); + assert_eq(actual_instruction.input1.data_len, instruction_0.input1.data_len); + assert_eq(actual_instruction.input2.selector, instruction_0.input2.selector); + assert_eq(actual_instruction.input2.protected, instruction_0.input2.protected); + assert_eq(actual_instruction.input2.type, instruction_0.input2.type); + assert_eq(actual_instruction.input2.data_len, instruction_0.input2.data_len); + assert_eq(actual_instruction.output.selector, instruction_0.output.selector); + assert_eq(actual_instruction.output.protected, instruction_0.output.protected); + assert_eq(actual_instruction.output.type, instruction_0.output.type); + assert_eq(actual_instruction.output.data_len, instruction_0.output.data_len); + + let actual_instruction = Program.get_instruction(1, actual_program_len, actual_program); + assert_eq(actual_instruction.primitive.class_hash, starkshell_hash); + assert_eq(actual_instruction.primitive.selector, instruction_1.primitive.selector); + assert_eq(actual_instruction.input1.selector, instruction_1.input1.selector); + assert_eq(actual_instruction.input1.protected, instruction_1.input1.protected); + assert_eq(actual_instruction.input1.type, instruction_1.input1.type); + assert_eq(actual_instruction.input1.data_len, instruction_1.input1.data_len); + assert_eq(actual_instruction.input2.selector, instruction_1.input2.selector); + assert_eq(actual_instruction.input2.protected, instruction_1.input2.protected); + assert_eq(actual_instruction.input2.type, instruction_1.input2.type); + assert_eq(actual_instruction.input2.data_len, instruction_1.input2.data_len); + assert_eq(actual_instruction.output.selector, instruction_1.output.selector); + assert_eq(actual_instruction.output.protected, instruction_1.output.protected); + assert_eq(actual_instruction.output.type, instruction_1.output.type); + assert_eq(actual_instruction.output.data_len, instruction_1.output.data_len); + + let actual_instruction = Program.get_instruction(2, actual_program_len, actual_program); + assert_eq(actual_instruction.primitive.class_hash, instruction_2.primitive.class_hash); + assert_eq(actual_instruction.primitive.selector, instruction_2.primitive.selector); + assert_eq(actual_instruction.input1.selector, instruction_2.input1.selector); + assert_eq(actual_instruction.input1.protected, instruction_2.input1.protected); + assert_eq(actual_instruction.input1.type, instruction_2.input1.type); + assert_eq(actual_instruction.input1.data_len, instruction_2.input1.data_len); + assert_eq(actual_instruction.input2.selector, instruction_2.input2.selector); + assert_eq(actual_instruction.input2.protected, instruction_2.input2.protected); + assert_eq(actual_instruction.input2.type, instruction_2.input2.type); + assert_eq(actual_instruction.input2.data_len, instruction_2.input2.data_len); + assert_eq(actual_instruction.output.selector, instruction_2.output.selector); + assert_eq(actual_instruction.output.protected, instruction_2.output.protected); + assert_eq(actual_instruction.output.type, instruction_2.output.type); + assert_eq(actual_instruction.output.data_len, instruction_2.output.data_len); + + let actual_instruction = Program.get_instruction(3, actual_program_len, actual_program); + assert_eq(actual_instruction.primitive.class_hash, instruction_3.primitive.class_hash); + assert_eq(actual_instruction.primitive.selector, instruction_3.primitive.selector); + assert_eq(actual_instruction.input1.selector, instruction_3.input1.selector); + assert_eq(actual_instruction.input1.protected, instruction_3.input1.protected); + assert_eq(actual_instruction.input1.type, instruction_3.input1.type); + assert_eq(actual_instruction.input1.data_len, instruction_3.input1.data_len); + assert_eq(actual_instruction.input2.selector, instruction_3.input2.selector); + assert_eq(actual_instruction.input2.protected, instruction_3.input2.protected); + assert_eq(actual_instruction.input2.type, instruction_3.input2.type); + assert_eq(actual_instruction.input2.data_len, instruction_3.input2.data_len); + assert_eq(actual_instruction.output.selector, instruction_3.output.selector); + assert_eq(actual_instruction.output.protected, instruction_3.output.protected); + assert_eq(actual_instruction.output.type, instruction_3.output.type); + assert_eq(actual_instruction.output.data_len, instruction_3.output.data_len); + + let actual_instruction = Program.get_instruction(4, actual_program_len, actual_program); + assert_eq(actual_instruction.primitive.class_hash, starkshell_hash); + assert_eq(actual_instruction.primitive.selector, instruction_4.primitive.selector); + assert_eq(actual_instruction.input1.selector, instruction_4.input1.selector); + assert_eq(actual_instruction.input1.protected, instruction_4.input1.protected); + assert_eq(actual_instruction.input1.type, instruction_4.input1.type); + assert_eq(actual_instruction.input1.data_len, instruction_4.input1.data_len); + assert_eq(actual_instruction.input2.selector, instruction_4.input2.selector); + assert_eq(actual_instruction.input2.protected, instruction_4.input2.protected); + assert_eq(actual_instruction.input2.type, instruction_4.input2.type); + assert_eq(actual_instruction.input2.data_len, instruction_4.input2.data_len); + assert_eq(actual_instruction.output.selector, instruction_4.output.selector); + assert_eq(actual_instruction.output.protected, instruction_4.output.protected); + assert_eq(actual_instruction.output.type, instruction_4.output.type); + assert_eq(actual_instruction.output.data_len, instruction_4.output.data_len); + + return (); +} From 841ae2d9bf5643a72ec1f343371acdcdb231528d Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Sat, 24 Dec 2022 09:30:22 +0100 Subject: [PATCH 6/8] refactor Remove redundant import --- src/starkshell/printInterpreteInstruction.cairo | 1 - src/starkshell/printMintContractCode.cairo | 1 - 2 files changed, 2 deletions(-) diff --git a/src/starkshell/printInterpreteInstruction.cairo b/src/starkshell/printInterpreteInstruction.cairo index 255f09b..39b3b4a 100644 --- a/src/starkshell/printInterpreteInstruction.cairo +++ b/src/starkshell/printInterpreteInstruction.cairo @@ -1,5 +1,4 @@ %builtins output -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.serialize import serialize_word from src.starkshell.interpreteInstruction import interpreteInstruction diff --git a/src/starkshell/printMintContractCode.cairo b/src/starkshell/printMintContractCode.cairo index 1381eb6..c7c223a 100644 --- a/src/starkshell/printMintContractCode.cairo +++ b/src/starkshell/printMintContractCode.cairo @@ -1,5 +1,4 @@ %builtins output -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.serialize import serialize_word from src.starkshell.mintContract import mintContract From 047afb7861827e052e05bc4fb1208f93b2939451 Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Sat, 24 Dec 2022 10:52:16 +0100 Subject: [PATCH 7/8] refactor Remove redundant alloc_locals --- src/starkshell/printInterpreteInstruction.cairo | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/starkshell/printInterpreteInstruction.cairo b/src/starkshell/printInterpreteInstruction.cairo index 39b3b4a..402e458 100644 --- a/src/starkshell/printInterpreteInstruction.cairo +++ b/src/starkshell/printInterpreteInstruction.cairo @@ -4,8 +4,6 @@ from starkware.cairo.common.serialize import serialize_word from src.starkshell.interpreteInstruction import interpreteInstruction func main{output_ptr: felt*}() { - alloc_locals; - let (felt_code_len, felt_code) = interpreteInstruction(); print(felt_code_len, felt_code); From 485075bba1f4b2a64ef2a0a000e9b506425483a4 Mon Sep 17 00:00:00 2001 From: "Thomas S. Bauer" Date: Sun, 25 Dec 2022 09:47:12 +0100 Subject: [PATCH 8/8] style Apply formatting --- src/bootstrap/Bootstrapper.cairo | 93 +++-- src/starkshell/interpreteInstruction.cairo | 25 +- src/starkshell/invertBoolean.cairo | 36 +- src/starkshell/mintContract.cairo | 56 +-- src/starkshell/mul.cairo | 4 +- src/starkshell/returnCalldata.cairo | 14 +- src/starkshell/setShellFun.cairo | 32 +- src/zkode/constants.cairo | 33 +- src/zkode/facets/starkshell/StarkShell.cairo | 4 +- src/zkode/facets/starkshell/library.cairo | 22 +- tests/ERC1155/test_ERC1155.cairo | 13 +- tests/ERC20/test_ERC20.cairo | 7 +- tests/ERC2535/test_diamondCut.cairo | 9 +- tests/ERC5114/test_ERC5114.cairo | 12 +- tests/ERC721/test_ERC721.cairo | 11 +- ...est_UniversalMetadata_no_token_facet.cairo | 2 +- .../test_UniversalMetadata_on_ERC1155.cairo | 7 +- ..._UniversalMetadata_on_ERC1155_prefix.cairo | 14 +- ...rsalMetadata_on_ERC1155_prefix_infix.cairo | 14 +- ...adata_on_ERC1155_prefix_infix_suffix.cairo | 34 +- tests/setup.cairo | 12 +- tests/starkshell/test_memory.cairo | 346 +++++------------- tests/starkshell/test_program.cairo | 160 ++++---- tests/starkshell/test_starkshell.cairo | 45 ++- 24 files changed, 414 insertions(+), 591 deletions(-) diff --git a/src/bootstrap/Bootstrapper.cairo b/src/bootstrap/Bootstrapper.cairo index 451bbba..304853b 100644 --- a/src/bootstrap/Bootstrapper.cairo +++ b/src/bootstrap/Bootstrapper.cairo @@ -109,7 +109,9 @@ func deployRootDiamond{ class_hash=_class.diamond, contract_address_salt=salt, constructor_calldata_size=DiamondCalldata.SIZE, - constructor_calldata=new (DiamondCalldata(0, 0, _class.rootDiamondFactory, _class.feltmap)), + constructor_calldata=new ( + DiamondCalldata(0, 0, _class.rootDiamondFactory, _class.feltmap) + ), deploy_from_zero=FALSE, ); } @@ -157,44 +159,61 @@ func init{ let (high, low) = split_felt(self); let facetCut_len = 6; - tempvar facetCut: FacetCut* = cast(new ( - FacetCut(_class.feltmap, FacetCutAction.Add), - FacetCut(_class.erc721, FacetCutAction.Add), - FacetCut(_class.starkshell, FacetCutAction.Add), - FacetCut(_class.diamondCut, FacetCutAction.Add), - FacetCut(_class.metadata, FacetCutAction.Add), - FacetCut(_class.flobDb, FacetCutAction.Add), - ), FacetCut*); - - let tmp_len = (BFRCalldata.SIZE + 2) + (ERC721Calldata.SIZE + 1) + (StarkShellCalldata.SIZE + 2) + (DiamondCutCalldata.SIZE + 1) + 12; - tempvar tmp = cast(new ( - BFRCalldata.SIZE + 1, - BFRCalldata.SIZE, - BFRCalldata( - _class.feltmap, - _class.erc721, - _class.flobDb, - _class.starkshell, - _class.diamondCut, - _class.metadata, - _class.erc1155, - _class.erc20, - _class.erc5114, + tempvar facetCut: FacetCut* = cast( + new ( + FacetCut(_class.feltmap, FacetCutAction.Add), + FacetCut(_class.erc721, FacetCutAction.Add), + FacetCut(_class.starkshell, FacetCutAction.Add), + FacetCut(_class.diamondCut, FacetCutAction.Add), + FacetCut(_class.metadata, FacetCutAction.Add), + FacetCut(_class.flobDb, FacetCutAction.Add), + ), + FacetCut*, + ); + + let tmp_len = (BFRCalldata.SIZE + 2) + (ERC721Calldata.SIZE + 1) + ( + StarkShellCalldata.SIZE + 2 + ) + (DiamondCutCalldata.SIZE + 1) + 12; + tempvar tmp = cast( + new ( + BFRCalldata.SIZE + 1, + BFRCalldata.SIZE, + BFRCalldata( + _class.feltmap, + _class.erc721, + _class.flobDb, + _class.starkshell, + _class.diamondCut, + _class.metadata, + _class.erc1155, + _class.erc20, + _class.erc5114, ), - ERC721Calldata.SIZE, - ERC721Calldata( - receiver=_owner, - tokenId_len=1, - tokenId_low=low, - tokenId_high=high, + ERC721Calldata.SIZE, + ERC721Calldata(receiver=_owner, tokenId_len=1, tokenId_low=low, tokenId_high=high), + StarkShellCalldata.SIZE + 1, + 2, + StarkShellCalldata( + Function(_setShellFun_selector, _setShellFun_hash, 0), + Function(_mintContract_selector, _mintContract_hash, 0), ), - StarkShellCalldata.SIZE + 1, - 2, - StarkShellCalldata(Function(_setShellFun_selector, _setShellFun_hash, 0), Function(_mintContract_selector, _mintContract_hash, 0)), - DiamondCutCalldata.SIZE, - DiamondCutCalldata(0), - 11, 0, 0, 0, 4, 184555836509371486644856095017587421344261193474617388276263770152936827443, 203998027954878725543997547266317984232748597657159516903365148909254028897, 202244606418614541364902086132942206699045874315590809968639424267107263609, 10754949894223100254076072945295018243026244912222009195, FALSE, 0, 0, // https://m4chgvnjpozvm7p7jeo7vj3susfrkuencv6j5bf3u6mokcshjmeq.arweave.net/ZwRzVal7s1Z9_0kd-qdypIsVUI0VfJ6Eu6eY5QpHSwk - ), felt*); + DiamondCutCalldata.SIZE, + DiamondCutCalldata(0), + 11, + 0, + 0, + 0, + 4, + 184555836509371486644856095017587421344261193474617388276263770152936827443, + 203998027954878725543997547266317984232748597657159516903365148909254028897, + 202244606418614541364902086132942206699045874315590809968639424267107263609, + 10754949894223100254076072945295018243026244912222009195, + FALSE, + 0, + 0, + ), + felt*, + ); let (local calldata: felt*) = alloc(); diff --git a/src/starkshell/interpreteInstruction.cairo b/src/starkshell/interpreteInstruction.cairo index a833206..0f292ee 100644 --- a/src/starkshell/interpreteInstruction.cairo +++ b/src/starkshell/interpreteInstruction.cairo @@ -31,23 +31,17 @@ func interpreteInstruction() -> (res_len: felt, res: felt*) { input1=NULLvar, input2=NULLvar, output=NULLvar, - ); + ); // res = exec(_program, _memory) tempvar instruction1 = Instruction( - primitive=Primitive(0, exec_keyword), - input1=Calldata, - input2=NULLvar, - output=ResultVar, - ); + primitive=Primitive(0, exec_keyword), input1=Calldata, input2=NULLvar, output=ResultVar + ); // return res tempvar instruction2 = Instruction( - primitive=Primitive(0, return_keyword), - input1=ResultVar, - input2=NULLvar, - output=NULLvar, - ); + primitive=Primitive(0, return_keyword), input1=ResultVar, input2=NULLvar, output=NULLvar + ); tempvar memory_layout = (ResultVar); @@ -57,13 +51,8 @@ func interpreteInstruction() -> (res_len: felt, res: felt*) { let felt_code_len = total_len + 1; tempvar felt_code: felt* = new ( - total_len, - instruction_len, - instruction0, - instruction1, - instruction2, - memory_layout, - ); + total_len, instruction_len, instruction0, instruction1, instruction2, memory_layout + ); return (felt_code_len, felt_code); } diff --git a/src/starkshell/invertBoolean.cairo b/src/starkshell/invertBoolean.cairo index 97b4493..aca5586 100644 --- a/src/starkshell/invertBoolean.cairo +++ b/src/starkshell/invertBoolean.cairo @@ -40,32 +40,21 @@ func invertBoolean() -> (res_len: felt, res: felt*) { Variable(var0_identifier, 0, 0, 0), Variable(sentinel_selector, 0, 0, 0), NULLvar, - ); + ); tempvar instruction1 = Instruction( - Primitive(0, return_keyword), - Variable(false_identifier, 0, 0, 0), - NULLvar, - NULLvar, - ); + Primitive(0, return_keyword), Variable(false_identifier, 0, 0, 0), NULLvar, NULLvar + ); tempvar instruction2 = Instruction( - Primitive(0, return_keyword), - Variable(true_identifier, 0, 0, 0), - NULLvar, - NULLvar, - ); + Primitive(0, return_keyword), Variable(true_identifier, 0, 0, 0), NULLvar, NULLvar + ); tempvar sentinel_var = Variable( - selector=sentinel_selector, - protected=FALSE, - type=0, - data_len=2, - ); + selector=sentinel_selector, protected=FALSE, type=0, data_len=2 + ); - tempvar memory_layout = ( - sentinel_var, 1, 2, - ); + tempvar memory_layout = (sentinel_var, 1, 2); let instruction_len = 3 * Instruction.SIZE; let memory_layout_len = 1 * Variable.SIZE + sentinel_var.data_len; @@ -73,13 +62,8 @@ func invertBoolean() -> (res_len: felt, res: felt*) { let felt_code_len = total_len + 1; tempvar felt_code: felt* = new ( - total_len, - instruction_len, - instruction0, - instruction1, - instruction2, - memory_layout, - ); + total_len, instruction_len, instruction0, instruction1, instruction2, memory_layout + ); return (felt_code_len, felt_code); } diff --git a/src/starkshell/mintContract.cairo b/src/starkshell/mintContract.cairo index ab60587..c4075f7 100644 --- a/src/starkshell/mintContract.cairo +++ b/src/starkshell/mintContract.cairo @@ -75,7 +75,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(caller_address_var, 0, 0, 0), input2=NULLvar, output=Variable(salt_var, 0, 0, 0), - ); + ); // salt = sum(balance.low + balance.high) tempvar instruction1 = Instruction( @@ -83,7 +83,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(salt_var, 0, 0, 0), input2=NULLvar, output=Variable(salt_var, 0, 0, 0), - ); + ); // salt = caller_address + salt tempvar instruction2 = Instruction( @@ -91,7 +91,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(salt_var, 0, 0, 0), input2=Variable(caller_address_var, 0, 0, 0), output=Variable(salt_var, 0, 0, 0), - ); + ); // Prepare deploy params tempvar instruction3 = Instruction( @@ -99,7 +99,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(diamond_hash_var, 0, 0, 0), input2=Variable(salt_var, 0, 0, 0), output=Variable(deploy_cfg_var, 0, 0, 0), - ); + ); // Prepare constructor calldata tempvar instruction4 = Instruction( @@ -107,7 +107,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(this_address_var, 0, 0, 0), input2=Variable(facet_key_var, 0, 0, 0), output=Variable(diamond_constructor_var, 0, 0, 0), - ); + ); // Pop deploy_cfg var tempvar instruction5 = Instruction( @@ -115,7 +115,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=NULLvar, input2=Variable(deploy_cfg_var, 0, 0, 0), output=Variable(deploy_cfg_var, 0, 0, 0), - ); + ); // deploy() tempvar instruction6 = Instruction( @@ -123,7 +123,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(deploy_cfg_var, 0, 0, 0), input2=Variable(diamond_constructor_var, 0, 0, 0), output=Variable(diamond_addr_var, 0, 0, 0), - ); + ); // convert address to token id tempvar instruction7 = Instruction( @@ -131,7 +131,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(diamond_addr_var, 0, 0, 0), input2=NULLvar, output=Variable(tokenId_var, 0, 0, 0), - ); + ); // mint token for address tempvar instruction8 = Instruction( @@ -139,7 +139,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(this_address_var, 0, 0, 0), input2=Variable(tokenId_var, 0, 0, 0), output=NULLvar, - ); + ); // diamond_address + diamondCut selector = diamondCut_var tempvar instruction9 = Instruction( @@ -147,7 +147,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(diamond_addr_var, 0, 0, 0), input2=Variable(diamondCut_func, 0, 0, 0), output=Variable(diamondCut_var, 0, 0, 0), - ); + ); // pop() tempvar instruction10 = Instruction( @@ -155,7 +155,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=NULLvar, input2=Variable(diamondCut_var, 0, 0, 0), output=Variable(diamondCut_var, 0, 0, 0), - ); + ); // push() tempvar instruction11 = Instruction( @@ -163,7 +163,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(calldata_var, 0, 0, 0), input2=NULLvar, output=Variable(calldata_var, 0, 0, 0), - ); + ); // diamondCut_var + calldata = diamondCut_var tempvar instruction12 = Instruction( @@ -171,7 +171,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(diamondCut_var, 0, 0, 0), input2=Variable(calldata_var, 0, 0, 0), output=Variable(diamondCut_var, 0, 0, 0), - ); + ); // pop() tempvar instruction13 = Instruction( @@ -179,7 +179,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=NULLvar, input2=Variable(diamondCut_var, 0, 0, 0), output=Variable(diamondCut_var, 0, 0, 0), - ); + ); // IDiamond.diamondCut(diamondCut_var) tempvar instruction14 = Instruction( @@ -187,7 +187,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(diamondCut_var, 0, 0, 0), input2=NULLvar, output=NULLvar, - ); + ); // self + caller = transferFrom_var tempvar instruction15 = Instruction( @@ -195,7 +195,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(this_address_var, 0, 0, 0), input2=Variable(caller_address_var, 0, 0, 0), output=Variable(transferFrom_var, 0, 0, 0), - ); + ); // pop() tempvar instruction16 = Instruction( @@ -203,7 +203,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=NULLvar, input2=Variable(transferFrom_var, 0, 0, 0), output=Variable(transferFrom_var, 0, 0, 0), - ); + ); // transfer(transferFrom_var) tempvar instruction17 = Instruction( @@ -211,7 +211,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(transferFrom_var, 0, 0, 0), input2=Variable(tokenId_var, 0, 0, 0), output=NULLvar, - ); + ); // return diamondAddress tempvar instruction18 = Instruction( @@ -219,7 +219,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re input1=Variable(diamond_addr_var, 0, 0, 0), input2=NULLvar, output=NULLvar, - ); + ); tempvar facet_key = Variable(facet_key_var, 0, 0, 3); tempvar diamond_addr = Variable(diamond_addr_var, 0, 0, 0); @@ -233,20 +233,26 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re tempvar salt = Variable(salt_var, 0, 0, 0); tempvar memory_layout = ( - facet_key, 16, 0, 0, // TODO bug source 16 is diamondCut only + facet_key, + 16, + 0, + 0, diamond_addr, tokenId, diamond_constructor_calldata, - diamond_hash, _diamond_hash, - diamondCut, diamondCut_func, + diamond_hash, + _diamond_hash, + diamondCut, + diamondCut_func, diamondCut_v, deploy_cfg, transferFrom_calldata, salt, - ); + ); let instruction_len = 19 * Instruction.SIZE; - let memory_layout_len = 10 * Variable.SIZE + facet_key.data_len + diamond_hash.data_len + diamondCut.data_len; + let memory_layout_len = 10 * Variable.SIZE + facet_key.data_len + diamond_hash.data_len + + diamondCut.data_len; let total_len = instruction_len + memory_layout_len + 1; let felt_code_len = total_len + 1; @@ -273,7 +279,7 @@ func mintContract(_diamond_hash: felt, _erc721_hash: felt) -> (res_len: felt, re instruction17, instruction18, memory_layout, - ); + ); return (felt_code_len, felt_code); } diff --git a/src/starkshell/mul.cairo b/src/starkshell/mul.cairo index 49aec3f..c43ff3d 100644 --- a/src/starkshell/mul.cairo +++ b/src/starkshell/mul.cairo @@ -33,14 +33,14 @@ func mul(_x: felt, _y: felt) -> (res_len: felt, res: felt*) { input1=Calldata, input2=NULLvar, output=mulvar, - ); + ); tempvar instruction1 = Instruction( primitive=Primitive(starkshell_hash, return_keyword), input1=mulvar, input2=NULLvar, output=NULLvar, - ); + ); tempvar program = new (instruction0, instruction1); tempvar memory = new (mulvar); diff --git a/src/starkshell/returnCalldata.cairo b/src/starkshell/returnCalldata.cairo index 4733cc5..bd92dc0 100644 --- a/src/starkshell/returnCalldata.cairo +++ b/src/starkshell/returnCalldata.cairo @@ -19,11 +19,8 @@ func returnCalldata() -> (res_len: felt, res: felt*) { tempvar NULLvar = Variable(0, 0, 0, 0); tempvar instruction0 = Instruction( - Primitive(0, return_keyword), - Variable(var0_identifier, 0, 0, 0), - NULLvar, - NULLvar, - ); + Primitive(0, return_keyword), Variable(var0_identifier, 0, 0, 0), NULLvar, NULLvar + ); tempvar memory_layout = (); @@ -32,12 +29,7 @@ func returnCalldata() -> (res_len: felt, res: felt*) { let total_len = instruction_len + memory_layout_len + 1; let felt_code_len = total_len + 1; - tempvar felt_code: felt* = new ( - total_len, - instruction_len, - instruction0, - memory_layout, - ); + tempvar felt_code: felt* = new (total_len, instruction_len, instruction0, memory_layout); return (felt_code_len, felt_code); } diff --git a/src/starkshell/setShellFun.cairo b/src/starkshell/setShellFun.cairo index 28a3654..dd6a35c 100644 --- a/src/starkshell/setShellFun.cairo +++ b/src/starkshell/setShellFun.cairo @@ -22,25 +22,14 @@ func setShellFun() -> (res_len: felt, res: felt*) { tempvar NULLvar = Variable(0, 0, 0, 0); tempvar instruction0 = Instruction( - Primitive(0, assert_only_owner_keyword), - NULLvar, - NULLvar, - NULLvar, - ); + Primitive(0, assert_only_owner_keyword), NULLvar, NULLvar, NULLvar + ); tempvar instruction1 = Instruction( - Primitive(0, set_function_keyword), - Variable(var0_identifier, 0, 0, 0), - NULLvar, - NULLvar, - ); - - tempvar instruction2 = Instruction( - Primitive(0, return_keyword), - NULLvar, - NULLvar, - NULLvar, - ); + Primitive(0, set_function_keyword), Variable(var0_identifier, 0, 0, 0), NULLvar, NULLvar + ); + + tempvar instruction2 = Instruction(Primitive(0, return_keyword), NULLvar, NULLvar, NULLvar); tempvar memory_layout = (); @@ -50,13 +39,8 @@ func setShellFun() -> (res_len: felt, res: felt*) { let felt_code_len = total_len + 1; tempvar felt_code: felt* = new ( - total_len, - instruction_len, - instruction0, - instruction1, - instruction2, - memory_layout, - ); + total_len, instruction_len, instruction0, instruction1, instruction2, memory_layout + ); return (felt_code_len, felt_code); } diff --git a/src/zkode/constants.cairo b/src/zkode/constants.cairo index f5ba668..0996e0f 100644 --- a/src/zkode/constants.cairo +++ b/src/zkode/constants.cairo @@ -29,18 +29,26 @@ namespace API { const __ZKLANG__EVENT = 0x315c4e503b7f8705e10f5e48d4899db38942f0874c59e0debd029d0e1dd9a26; const __ZKLANG__BRANCH = 0xce691f9bc53c77ba4a888fec927f8beb04746d9f4256b40c4566af3a100ea5; const __ZKLANG__REVERT = 0x28089cf47fb4b74d7ca26ab7ac970b2dc2b1bd4ed7dc25ca96784bc366a815f; - const __ZKLANG__CALLDATA_VAR = 0x3c6f3599ac37319bbc36d2acb3ea0b2567cdbe7fd6ed09616db6414f36bdc40; - const __ZKLANG__SET_FUNCTION = 0x18ae100d40c97134a859d0645d6b26e9c64a971383a16c41bc2aa306cd97972; + const __ZKLANG__CALLDATA_VAR = 0x3c6f3599ac37319bbc36d2acb3ea0b2567cdbe7fd6ed09616db6414f36bdc40 + ; + const __ZKLANG__SET_FUNCTION = 0x18ae100d40c97134a859d0645d6b26e9c64a971383a16c41bc2aa306cd97972 + ; const __ZKLANG__EXEC = 0x1420ce4716273931c8d8177eb8b3996fafbf893270232b06f31b5189858987b; - const __ZKLANG__ASSERT_ONLY_OWNER = 0x39549628361e8cbb303e3c959c8576de71ccf55f61a66b77e3067f0d3d7c90c; - const __ZKLANG__CALLER_ADDRESS_VAR = 0x322f3db6714056d8d260dfc87d0ebe50e764b25f536f9aea41d6544f025077b; - const __ZKLANG__CONTRACT_ADDRESS_VAR = 0x3b6b7fdff7b925dac637ced22595f8b097b895737f63123221f0e4ec0c89242; - const __ZKLANG__CALL_CONTRACT = 0x312f27d7b0a81e57007cc55c68e29ea785910acec2974f2bad0e32bc93147d5; + const __ZKLANG__ASSERT_ONLY_OWNER = 0x39549628361e8cbb303e3c959c8576de71ccf55f61a66b77e3067f0d3d7c90c + ; + const __ZKLANG__CALLER_ADDRESS_VAR = 0x322f3db6714056d8d260dfc87d0ebe50e764b25f536f9aea41d6544f025077b + ; + const __ZKLANG__CONTRACT_ADDRESS_VAR = 0x3b6b7fdff7b925dac637ced22595f8b097b895737f63123221f0e4ec0c89242 + ; + const __ZKLANG__CALL_CONTRACT = 0x312f27d7b0a81e57007cc55c68e29ea785910acec2974f2bad0e32bc93147d5 + ; // TODO make NOOP zero and transform during init const __ZKLANG__NOOP = 0x1f0ddfce203a54a45080b91f88d9af5e165c95f44efaa5edc1506a2dad901dd; - const __ZKLANG__FELT_TO_UINT256 = 0x3726882ac05e3fc9b328e583644a4818c6fca2ca42d90d300f0d451eba6fdcc; + const __ZKLANG__FELT_TO_UINT256 = 0x3726882ac05e3fc9b328e583644a4818c6fca2ca42d90d300f0d451eba6fdcc + ; const __ZKLANG__DEPLOY = 0x198a90daab7e1dfab015a5564a3305ffcaaf28717870a466d15194efdcca578; - const __ZKLANG__FALSE_VAR = 0x29fa8f7f93e496ecbc2d5a3dd8462c9a743f89dd5196e4be6a32ec3d1cf11a4; + const __ZKLANG__FALSE_VAR = 0x29fa8f7f93e496ecbc2d5a3dd8462c9a743f89dd5196e4be6a32ec3d1cf11a4 + ; const __ZKLANG__TRUE_VAR = 0x5b053620a9db99726fb9138818c2d9e12e212722320e03b1da43e0dc46da0d; } } @@ -109,7 +117,8 @@ namespace FUNCTION_SELECTORS { const isApprovedForAll = 0x21cdf9aedfed41bc4485ae779fda471feca12075d9127a0fc70ac6b3b3d9c30; const setApprovalForAll = 0x2d4c8ea4c8fb9f571d1f6f9b7692fff8e5ceaf73b1df98e7da8c1109b39ae9a; const safeTransferFrom = 0x19d59d013d4aa1a8b1ce4c8299086f070733b453c02d0dc46e735edc04d6444; - const safeBatchTransferFrom = 0x23cc35d21c405aa7adf1f3afcf558aec0dbe6a45cade725420609aef87e9035; + const safeBatchTransferFrom = 0x23cc35d21c405aa7adf1f3afcf558aec0dbe6a45cade725420609aef87e9035 + ; } namespace ERC1155Metadata { @@ -120,7 +129,8 @@ namespace FUNCTION_SELECTORS { const __constructor__ = 0x3b9a86822e238443322f8092dd01ed69fb0d96d2fad90e9ad9ba03f8e92097b; const __destructor__ = 0x2127299f0c39ad6a0f5a7ccb0857ab472c30192b18dd40a88a5af64edd63a74; const __pub_func__ = 0x2d75e96b04d57d3c04af66c6b24042eee64c95f792ad16cc2404154690a2c04; - const __supports_interface__ = 0x20f621f78ecca5435389efa53ca29525b75fe9745044ce3b56b4b1e6056d791; + const __supports_interface__ = 0x20f621f78ecca5435389efa53ca29525b75fe9745044ce3b56b4b1e6056d791 + ; const __royalty_info = 0xef10f72befea4b2767793ab9151f232f087d5a39ad0d959a7406a84aaaf55a; } @@ -140,7 +150,8 @@ namespace FUNCTION_SELECTORS { namespace ERC4906 { const updateTokenURI = 0x2ce2072fc0e89a2053fac74913af88590b52e043d8a71a775737487a427e3d0; - const updateTokenBatchURI = 0x3c6f820fdee2e32345dc4f820b22fcdf1e015a504eabc9d9478aa24ce57e480; + const updateTokenBatchURI = 0x3c6f820fdee2e32345dc4f820b22fcdf1e015a504eabc9d9478aa24ce57e480 + ; } namespace ERC5007 { diff --git a/src/zkode/facets/starkshell/StarkShell.cairo b/src/zkode/facets/starkshell/StarkShell.cairo index 5543faf..920f97d 100644 --- a/src/zkode/facets/starkshell/StarkShell.cairo +++ b/src/zkode/facets/starkshell/StarkShell.cairo @@ -48,7 +48,9 @@ func __default__{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr let (local this_starkshell_hash: felt) = IDiamond.facetAddress(self, selector); // if repo is 0 assume that this contract holds the code - local normalized_repo_address: felt = Library._if_x_is_zero_then_y_else_x(fun.repo_address, self); + local normalized_repo_address: felt = Library._if_x_is_zero_then_y_else_x( + fun.repo_address, self + ); with_attr error_message("LOADING CODE FAILED") { let (program_raw_len, program_raw) = IFlobDB.load( diff --git a/src/zkode/facets/starkshell/library.cairo b/src/zkode/facets/starkshell/library.cairo index 9caece5..0f4d512 100644 --- a/src/zkode/facets/starkshell/library.cairo +++ b/src/zkode/facets/starkshell/library.cairo @@ -178,18 +178,12 @@ namespace Memory { alloc_locals; tempvar false_var = new Variable( - selector=API.CORE.__ZKLANG__FALSE_VAR, - protected=TRUE, - type=DataTypes.BOOL, - data_len=1, - ); + selector=API.CORE.__ZKLANG__FALSE_VAR, protected=TRUE, type=DataTypes.BOOL, data_len=1 + ); tempvar true_var = new Variable( - selector=API.CORE.__ZKLANG__TRUE_VAR, - protected=TRUE, - type=DataTypes.BOOL, - data_len=1, - ); + selector=API.CORE.__ZKLANG__TRUE_VAR, protected=TRUE, type=DataTypes.BOOL, data_len=1 + ); memcpy(_ptr + _ptr_len, false_var, Variable.SIZE); assert _ptr[_ptr_len + Variable.SIZE] = FALSE; @@ -208,7 +202,7 @@ namespace Memory { protected=TRUE, type=DataTypes.FELT, data_len=1, - ); + ); let (contract_address) = get_contract_address(); memcpy(_ptr + _ptr_len, contract_address_var, Variable.SIZE); assert _ptr[_ptr_len + Variable.SIZE] = contract_address; @@ -224,7 +218,7 @@ namespace Memory { protected=TRUE, type=DataTypes.FELT, data_len=1, - ); + ); let (caller) = get_caller_address(); memcpy(_ptr + _ptr_len, caller_address_var, Variable.SIZE); assert _ptr[_ptr_len + Variable.SIZE] = caller; @@ -240,7 +234,7 @@ namespace Memory { protected=FALSE, type=DataTypes.FELT, data_len=_calldata_len, - ); + ); memcpy(_ptr + _ptr_len, calldata_var, Variable.SIZE); memcpy(_ptr + _ptr_len + Variable.SIZE, _calldata, _calldata_len); @@ -392,7 +386,7 @@ namespace Memory { let total_var_size = Variable.SIZE + _memory[Variable.data_len]; if (_memory[Variable.selector] == _selector) { - return (start=_i, end=_i + total_var_size,); + return (start=_i, end=_i + total_var_size); } return get_index_of_var_in_memory( diff --git a/tests/ERC1155/test_ERC1155.cairo b/tests/ERC1155/test_ERC1155.cairo index 51a4956..b585c56 100644 --- a/tests/ERC1155/test_ERC1155.cairo +++ b/tests/ERC1155/test_ERC1155.cairo @@ -69,7 +69,7 @@ func getERC1155Selectors() -> ERC1155Selectors { setApprovalForAll, safeTransferFrom, safeBatchTransferFrom, - ); + ); return selectors; } @@ -98,14 +98,9 @@ func __setup__{ tempvar calldata = new ( ERC1155Calldata.SIZE, ERC1155Calldata( - receiver=User, - tokenBatch_len=1, - tokenBatch0=TokenBatch( - Uint256(1, 0), - Uint256(1, 0), - ), - ), - ); + receiver=User, tokenBatch_len=1, tokenBatch0=TokenBatch(Uint256(1, 0), Uint256(1, 0)) + ), + ); %{ stop_prank_callable = start_prank( ids.User, target_contract_address=context.rootDiamond diff --git a/tests/ERC20/test_ERC20.cairo b/tests/ERC20/test_ERC20.cairo index 406f372..33d47f0 100644 --- a/tests/ERC20/test_ERC20.cairo +++ b/tests/ERC20/test_ERC20.cairo @@ -76,7 +76,7 @@ func getERC20Selectors() -> ERC20Selectors { transferFrom, increaseAllowance, decreaseAllowance, - ); + ); return selectors; } @@ -103,9 +103,8 @@ func __setup__{ let calldata_len = ERC20Calldata.SIZE + 1; tempvar calldata = new ( - ERC20Calldata.SIZE, - ERC20Calldata(receiver=User, balance=Uint256(1000000, 0)) - ); + ERC20Calldata.SIZE, ERC20Calldata(receiver=User, balance=Uint256(1000000, 0)) + ); %{ stop_prank_callable = start_prank( diff --git a/tests/ERC2535/test_diamondCut.cairo b/tests/ERC2535/test_diamondCut.cairo index 7d07fe9..9fe502e 100644 --- a/tests/ERC2535/test_diamondCut.cairo +++ b/tests/ERC2535/test_diamondCut.cairo @@ -116,12 +116,9 @@ func test_diamondCut_add_erc721{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, tempvar calldata = new ( ERC721Calldata.SIZE, ERC721Calldata( - receiver=User, - tokenId_len=2, - tokenId0=Uint256(1, 0), - tokenId1=Uint256(3, 0), - ), - ); + receiver=User, tokenId_len=2, tokenId0=Uint256(1, 0), tokenId1=Uint256(3, 0) + ), + ); %{ stop_prank_callable = start_prank( diff --git a/tests/ERC5114/test_ERC5114.cairo b/tests/ERC5114/test_ERC5114.cairo index 4ef9abf..f7920ae 100644 --- a/tests/ERC5114/test_ERC5114.cairo +++ b/tests/ERC5114/test_ERC5114.cairo @@ -47,9 +47,7 @@ func getERC5114Selectors() -> ERC5114Selectors { [setattr(ids, v, get_selector_from_name(v)) for v in variables] %} - local selectors: ERC5114Selectors = ERC5114Selectors( - ownerOf, - ); + local selectors: ERC5114Selectors = ERC5114Selectors(ownerOf); return selectors; } @@ -76,12 +74,8 @@ func __setup__{ let calldata_len = ERC5114Calldata.SIZE + 1; tempvar calldata = new ( - ERC5114Calldata.SIZE, - ERC5114Calldata( - tokenId=Uint256(1, 0), - nft=NFT(0x789, Uint256(2, 0)), - ) - ); + ERC5114Calldata.SIZE, ERC5114Calldata(tokenId=Uint256(1, 0), nft=NFT(0x789, Uint256(2, 0))) + ); %{ stop_prank_callable = start_prank( diff --git a/tests/ERC721/test_ERC721.cairo b/tests/ERC721/test_ERC721.cairo index f494659..bc638df 100644 --- a/tests/ERC721/test_ERC721.cairo +++ b/tests/ERC721/test_ERC721.cairo @@ -78,7 +78,7 @@ func getERC721Selectors() -> ERC721Selectors { safeTransferFrom, setApprovalForAll, transferFrom, - ); + ); return selectors; } @@ -107,12 +107,9 @@ func __setup__{ tempvar calldata = new ( ERC721Calldata.SIZE, ERC721Calldata( - receiver=User, - tokenId_len=2, - tokenId0=Uint256(1, 0), - tokenId1=Uint256(3, 0), - ), - ); + receiver=User, tokenId_len=2, tokenId0=Uint256(1, 0), tokenId1=Uint256(3, 0) + ), + ); %{ stop_prank_callable = start_prank( diff --git a/tests/UniversalMetadata/test_UniversalMetadata_no_token_facet.cairo b/tests/UniversalMetadata/test_UniversalMetadata_no_token_facet.cairo index 43e7094..114ea93 100644 --- a/tests/UniversalMetadata/test_UniversalMetadata_no_token_facet.cairo +++ b/tests/UniversalMetadata/test_UniversalMetadata_no_token_facet.cairo @@ -43,7 +43,7 @@ func __setup__{ // User mints a diamond with UniversalMetadata tempvar facetCut = new FacetCut(ch.metadata, FacetCutAction.Add); let facetCut_len = 1; - tempvar calldata: felt* = new (7, 0, 0, 0, 0, 0, 0, 0,); + tempvar calldata: felt* = new (7, 0, 0, 0, 0, 0, 0, 0); let calldata_len = 8; %{ stop_prank = start_prank(ids.User, ids.rootDiamond) %} diff --git a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155.cairo b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155.cairo index faf9c96..5f5a5d8 100644 --- a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155.cairo +++ b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155.cairo @@ -41,9 +41,12 @@ func __setup__{ let ch: ClassHash = getClassHashes(); // User mints a diamond with UniversalMetadata and ERC-1155 - tempvar facetCut: FacetCut* = cast(new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add),), FacetCut*); + tempvar facetCut: FacetCut* = cast( + new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add)), + FacetCut*, + ); let facetCut_len = 2; - tempvar calldata: felt* = new (7, 0, 0, 0, 0, 0, 0, 0, 6, User, 1, 1, 0, 1, 0,); + tempvar calldata: felt* = new (7, 0, 0, 0, 0, 0, 0, 0, 6, User, 1, 1, 0, 1, 0); let calldata_len = 15; %{ stop_prank = start_prank(ids.User, ids.rootDiamond) %} diff --git a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix.cairo b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix.cairo index 2bb61b3..da1d44d 100644 --- a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix.cairo +++ b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix.cairo @@ -42,10 +42,7 @@ func getTestData{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr ids.prefix1, ids.prefix2 = array[0], array[1] %} - local data: TestData = TestData( - prefix1, - prefix2, - ); + local data: TestData = TestData(prefix1, prefix2); return data; } @@ -67,9 +64,14 @@ func __setup__{ // User mints a test diamond and adds UniversalMetadata and ERC-1155 let data = getTestData(); - tempvar facetCut: FacetCut* = cast(new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add),), FacetCut*); + tempvar facetCut: FacetCut* = cast( + new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add)), + FacetCut*, + ); let facetCut_len = 2; - tempvar calldata: felt* = new (9, 0, 0, 0, TestData.SIZE, data.prefix1, data.prefix2, FALSE, 0, 0, 6, User, 1, 1, 0, 1, 0); + tempvar calldata: felt* = new ( + 9, 0, 0, 0, TestData.SIZE, data.prefix1, data.prefix2, FALSE, 0, 0, 6, User, 1, 1, 0, 1, 0 + ); let calldata_len = 17; %{ stop_prank = start_prank(ids.User, ids.rootDiamond) %} let (diamond_address) = ITCF.mintContract( diff --git a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix.cairo b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix.cairo index a9677da..50b2c01 100644 --- a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix.cairo +++ b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix.cairo @@ -42,10 +42,7 @@ func getTestData{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr ids.prefix1, ids.prefix2 = array[0], array[1] %} - local data: TestData = TestData( - prefix1, - prefix2, - ); + local data: TestData = TestData(prefix1, prefix2); return data; } @@ -67,9 +64,14 @@ func __setup__{ // User mints a diamond and adds UniversalMetadata and ERC-1155 let data = getTestData(); - tempvar facetCut: FacetCut* = cast(new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add),), FacetCut*); + tempvar facetCut: FacetCut* = cast( + new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add)), + FacetCut*, + ); let facetCut_len = 2; - tempvar calldata: felt* = new (9, 0, 0, 0, TestData.SIZE, data.prefix1, data.prefix2, TRUE, 0, 0, 6, User, 1, 1, 0, 1, 0); + tempvar calldata: felt* = new ( + 9, 0, 0, 0, TestData.SIZE, data.prefix1, data.prefix2, TRUE, 0, 0, 6, User, 1, 1, 0, 1, 0 + ); let calldata_len = 17; %{ stop_prank = start_prank(ids.User, ids.rootDiamond) %} diff --git a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix_suffix.cairo b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix_suffix.cairo index 2111f82..cfd0821 100644 --- a/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix_suffix.cairo +++ b/tests/UniversalMetadata/test_UniversalMetadata_on_ERC1155_prefix_infix_suffix.cairo @@ -49,12 +49,7 @@ func getTestData{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr ids.suffix1, ids.suffix2 = array[0], array[1] %} - local data: TestData = TestData( - prefix1, - prefix2, - suffix1, - suffix2, - ); + local data: TestData = TestData(prefix1, prefix2, suffix1, suffix2); return data; } @@ -76,9 +71,32 @@ func __setup__{ // User mints a diamond and adds UniversalMetadata and ERC-1155 let data = getTestData(); - tempvar facetCut: FacetCut* = cast(new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add),), FacetCut*); + tempvar facetCut: FacetCut* = cast( + new (FacetCut(ch.metadata, FacetCutAction.Add), FacetCut(ch.erc1155, FacetCutAction.Add)), + FacetCut*, + ); let facetCut_len = 2; - tempvar calldata: felt* = new (11, 0, 0, 0, 2, data.prefix1, data.prefix2, TRUE, 2, data.suffix1, data.suffix2, 0, 6, User, 1, 1, 0, 1, 0); + tempvar calldata: felt* = new ( + 11, + 0, + 0, + 0, + 2, + data.prefix1, + data.prefix2, + TRUE, + 2, + data.suffix1, + data.suffix2, + 0, + 6, + User, + 1, + 1, + 0, + 1, + 0, + ); let calldata_len = 19; %{ stop_prank = start_prank(ids.User, ids.rootDiamond) %} diff --git a/tests/setup.cairo b/tests/setup.cairo index a414735..c0372fa 100644 --- a/tests/setup.cairo +++ b/tests/setup.cairo @@ -38,10 +38,7 @@ func getSelectors() -> Selector { [setattr(ids, v, getattr(context, v)) if hasattr(context, v) else setattr(ids, v, 0) for v in variables] %} - local selectors: Selector = Selector( - mintContract, - setShellFun, - ); + local selectors: Selector = Selector(mintContract, setShellFun); return selectors; } @@ -89,7 +86,7 @@ func getClassHashes() -> ClassHash { rootDiamondFactory, starkshell, metadata, - ); + ); return classHashes; } @@ -112,10 +109,7 @@ func getAddresses() -> Address { [setattr(ids, v, getattr(context, v)) if hasattr(context, v) else setattr(ids, v, 0) for v in variables] %} - local addresses: Address = Address( - rootDiamond, - rootFactory, - ); + local addresses: Address = Address(rootDiamond, rootFactory); return addresses; } diff --git a/tests/starkshell/test_memory.cairo b/tests/starkshell/test_memory.cairo index f0f341b..0f89d85 100644 --- a/tests/starkshell/test_memory.cairo +++ b/tests/starkshell/test_memory.cairo @@ -22,17 +22,23 @@ func test_init_memory_on_empty_calldata_and_empty_memory{ let (local expected_memory: felt*) = alloc(); let expected_memory_len = 0; - tempvar calldata_var = new Variable(API.CORE.__ZKLANG__CALLDATA_VAR, FALSE, DataTypes.FELT, _calldata_len); + tempvar calldata_var = new Variable( + API.CORE.__ZKLANG__CALLDATA_VAR, FALSE, DataTypes.FELT, _calldata_len + ); tempvar calldata_var_len = Variable.SIZE + calldata_var.data_len; memcpy(expected_memory + expected_memory_len, calldata_var, calldata_var_len); tempvar expected_memory_len = expected_memory_len + calldata_var_len; - tempvar caller_address_var = new Variable(API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1); + tempvar caller_address_var = new Variable( + API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1 + ); tempvar caller_address_var_len = Variable.SIZE + caller_address_var.data_len; memcpy(expected_memory + expected_memory_len, caller_address_var, caller_address_var_len); tempvar expected_memory_len = expected_memory_len + caller_address_var_len; - tempvar contract_address_var = new Variable(API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1); + tempvar contract_address_var = new Variable( + API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1 + ); tempvar contract_address_var_len = Variable.SIZE + contract_address_var.data_len; memcpy(expected_memory + expected_memory_len, contract_address_var, contract_address_var_len); tempvar expected_memory_len = expected_memory_len + contract_address_var_len; @@ -88,13 +94,17 @@ func test_init_memory_on_non_single_width_calldata_on_empty_memory{ let (local expected_memory: felt*) = alloc(); let expected_memory_len = 0; - tempvar calldata_var = new Variable(API.CORE.__ZKLANG__CALLDATA_VAR, FALSE, DataTypes.FELT, _calldata_len); + tempvar calldata_var = new Variable( + API.CORE.__ZKLANG__CALLDATA_VAR, FALSE, DataTypes.FELT, _calldata_len + ); tempvar calldata_var_len = Variable.SIZE + calldata_var.data_len; memcpy(expected_memory + expected_memory_len, calldata_var, Variable.SIZE); memcpy(expected_memory + expected_memory_len + Variable.SIZE, _calldata, _calldata_len); tempvar expected_memory_len = expected_memory_len + calldata_var_len; - tempvar caller_address_var = new Variable(API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1); + tempvar caller_address_var = new Variable( + API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1 + ); tempvar caller_address_data = new (0x7); tempvar caller_address_var_len = Variable.SIZE + caller_address_var.data_len; memcpy(expected_memory + expected_memory_len, caller_address_var, Variable.SIZE); @@ -105,7 +115,9 @@ func test_init_memory_on_non_single_width_calldata_on_empty_memory{ ); tempvar expected_memory_len = expected_memory_len + caller_address_var_len; - tempvar contract_address_var = new Variable(API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1); + tempvar contract_address_var = new Variable( + API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1 + ); tempvar caller_address_data = new (0x13); tempvar contract_address_var_len = Variable.SIZE + contract_address_var.data_len; memcpy(expected_memory + expected_memory_len, contract_address_var, Variable.SIZE); @@ -156,13 +168,17 @@ func test_init_memory_on_calldata_with_five_elements_on_empty_memory{ let (local expected_memory: felt*) = alloc(); let expected_memory_len = 0; - tempvar calldata_var = new Variable(API.CORE.__ZKLANG__CALLDATA_VAR, FALSE, DataTypes.FELT, _calldata_len); + tempvar calldata_var = new Variable( + API.CORE.__ZKLANG__CALLDATA_VAR, FALSE, DataTypes.FELT, _calldata_len + ); tempvar calldata_var_len = Variable.SIZE + calldata_var.data_len; memcpy(expected_memory + expected_memory_len, calldata_var, Variable.SIZE); memcpy(expected_memory + expected_memory_len + Variable.SIZE, _calldata, _calldata_len); tempvar expected_memory_len = expected_memory_len + calldata_var_len; - tempvar caller_address_var = new Variable(API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1); + tempvar caller_address_var = new Variable( + API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1 + ); tempvar caller_address_data = new (0x7); tempvar caller_address_var_len = Variable.SIZE + caller_address_var.data_len; memcpy(expected_memory + expected_memory_len, caller_address_var, Variable.SIZE); @@ -173,7 +189,9 @@ func test_init_memory_on_calldata_with_five_elements_on_empty_memory{ ); tempvar expected_memory_len = expected_memory_len + caller_address_var_len; - tempvar contract_address_var = new Variable(API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1); + tempvar contract_address_var = new Variable( + API.CORE.__ZKLANG__CALLER_ADDRESS_VAR, TRUE, DataTypes.FELT, 1 + ); tempvar contract_address_data = new (0x7); tempvar caller_address_var_len = Variable.SIZE + contract_address_var.data_len; memcpy(expected_memory + expected_memory_len, contract_address_var, Variable.SIZE); @@ -222,40 +240,21 @@ func test_is_variable_in_memory_returns_true_if_var_in_memory{ }() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -309,40 +308,21 @@ func test_is_variable_in_memory_returns_false_if_var_not_in_non_empty_memory{ }() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -396,40 +376,21 @@ func test_get_index_of_var_in_memory{ }() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -487,40 +448,21 @@ func test_split_memory_split_at_first_variable{ }() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -560,40 +502,21 @@ func test_split_memory_split_at_last_variable{ }() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -633,40 +556,21 @@ func test_split_memory_split_at_a_middle_variable{ }() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -704,40 +608,21 @@ func test_split_memory_split_at_a_middle_variable{ func test_load_variable{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -808,40 +693,21 @@ func test_load_variable{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_ch func test_load_variable_payload{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=1, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=1, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=TRUE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=TRUE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -900,40 +766,21 @@ func test_load_variable_payload{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, func test_update_variable{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=0, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=0, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=FALSE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=FALSE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); @@ -1008,40 +855,21 @@ func test_update_variable_reverts_if_consts_are_updated{ }() { alloc_locals; - tempvar var0 = new Variable( - selector=3, - protected=FALSE, - type=DataTypes.FELT, - data_len=5, - ); + tempvar var0 = new Variable(selector=3, protected=FALSE, type=DataTypes.FELT, data_len=5); tempvar var0_data = new (4, 3, 2, 1, 0); - tempvar var1 = new Variable( - selector=6, - protected=FALSE, - type=DataTypes.BOOL, - data_len=1, - ); + tempvar var1 = new Variable(selector=6, protected=FALSE, type=DataTypes.BOOL, data_len=1); tempvar var1_data = new (TRUE); - tempvar var2 = new Variable( - selector=2, - protected=TRUE, - type=DataTypes.BOOL, - data_len=3, - ); + tempvar var2 = new Variable(selector=2, protected=TRUE, type=DataTypes.BOOL, data_len=3); tempvar var2_data = new (TRUE, FALSE, TRUE); - tempvar var3 = new Variable( - selector=7, - protected=FALSE, - type=DataTypes.BOOL, - data_len=2, - ); + tempvar var3 = new Variable(selector=7, protected=FALSE, type=DataTypes.BOOL, data_len=2); tempvar var3_data = new (TRUE, FALSE); let (local memory: felt*) = alloc(); - let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + var3.data_len; + let memory_len = 4 * Variable.SIZE + var0.data_len + var1.data_len + var2.data_len + + var3.data_len; // Copy first variable memcpy(memory, var0, Variable.SIZE); diff --git a/tests/starkshell/test_program.cairo b/tests/starkshell/test_program.cairo index 50b4401..a431b84 100644 --- a/tests/starkshell/test_program.cairo +++ b/tests/starkshell/test_program.cairo @@ -17,20 +17,20 @@ func test_get_instruction{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(1, 1), Variable(0, 1, 2, 3), Variable(0, 0, 0, 0), Variable(4, 5, 6, 7), - ); + Primitive(1, 1), Variable(0, 1, 2, 3), Variable(0, 0, 0, 0), Variable(4, 5, 6, 7) + ); tempvar instruction_1 = new Instruction( - Primitive(2, 2), Variable(8, 9, 10, 11), Variable(0, 0, 0, 0), Variable(12, 13, 14, 15), - ); + Primitive(2, 2), Variable(8, 9, 10, 11), Variable(0, 0, 0, 0), Variable(12, 13, 14, 15) + ); tempvar instruction_2 = new Instruction( - Primitive(3, 3), Variable(0, 0, -1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(3, 3), Variable(0, 0, -1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 2, 3), Variable(0, 0, 0, 0), Variable(4, 5, 6, 7), - ); + Primitive(4, 4), Variable(0, 1, 2, 3), Variable(0, 0, 0, 0), Variable(4, 5, 6, 7) + ); tempvar instruction_4 = new Instruction( - Primitive(5, 5), Variable(8, 9, 10, 11), Variable(0, 0, 0, 0), Variable(12, 13, 14, 15), - ); + Primitive(5, 5), Variable(8, 9, 10, 11), Variable(0, 0, 0, 0), Variable(12, 13, 14, 15) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); @@ -136,20 +136,20 @@ func test_validate_reverts_on_non_boolean_protected{ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_1 = new Instruction( - Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), - ); + Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1) + ); tempvar instruction_2 = new Instruction( - Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 3, 0, 0), - ); + Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 3, 0, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), - ); + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1) + ); tempvar instruction_4 = new Instruction( - Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), - ); + Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); @@ -173,20 +173,20 @@ func test_validate_reverts_on_unknown_type_key{ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_1 = new Instruction( - Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), - ); + Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1) + ); tempvar instruction_2 = new Instruction( - Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 3, 0), - ); + Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 3, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), - ); + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1) + ); tempvar instruction_4 = new Instruction( - Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), - ); + Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); @@ -210,20 +210,20 @@ func test_validate_returns_nothing_on_anything_else{ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_1 = new Instruction( - Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), - ); + Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1) + ); tempvar instruction_2 = new Instruction( - Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 1, 0), - ); + Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 1, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), - ); + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1) + ); tempvar instruction_4 = new Instruction( - Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), - ); + Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); @@ -246,20 +246,20 @@ func test_replace_zero_class_hashes_with_self{ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(0, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(0, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_1 = new Instruction( - Primitive(0, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), - ); + Primitive(0, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1) + ); tempvar instruction_2 = new Instruction( - Primitive(1, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 1, 0), - ); + Primitive(1, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 1, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), - ); + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1) + ); tempvar instruction_4 = new Instruction( - Primitive(0, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), - ); + Primitive(0, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); @@ -365,20 +365,20 @@ func test_prepare_reverts_on_non_boolean_protected{ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_1 = new Instruction( - Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), - ); + Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1) + ); tempvar instruction_2 = new Instruction( - Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 3, 0, 0), - ); + Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 3, 0, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), - ); + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1) + ); tempvar instruction_4 = new Instruction( - Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), - ); + Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); @@ -403,20 +403,20 @@ func test_prepare_reverts_on_unknown_type_key{ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(1, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_1 = new Instruction( - Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), - ); + Primitive(2, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1) + ); tempvar instruction_2 = new Instruction( - Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 3, 0), - ); + Primitive(3, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 3, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), - ); + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1) + ); tempvar instruction_4 = new Instruction( - Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), - ); + Primitive(5, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); @@ -441,20 +441,20 @@ func test_prepare_replaces_zero_class_hash_with_starkshell_hash{ let program_len = 5 * Instruction.SIZE; tempvar instruction_0 = new Instruction( - Primitive(0, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0), - ); + Primitive(0, 1), Variable(0, 1, 1, 0), Variable(0, 0, 0, 0), Variable(0, 0, 0, 0) + ); tempvar instruction_1 = new Instruction( - Primitive(0, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1), - ); + Primitive(0, 2), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(0, 1, 1, 1) + ); tempvar instruction_2 = new Instruction( - Primitive(1, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 1, 0), - ); + Primitive(1, 3), Variable(0, 0, 1, 0), Variable(0, 0, 0, 0), Variable(0, 1, 1, 0) + ); tempvar instruction_3 = new Instruction( - Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1), - ); + Primitive(4, 4), Variable(0, 1, 1, 1), Variable(0, 0, 0, 0), Variable(1, 0, 0, 1) + ); tempvar instruction_4 = new Instruction( - Primitive(0, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1), - ); + Primitive(0, 5), Variable(1, 0, 1, 1), Variable(0, 0, 0, 0), Variable(1, 1, 1, 1) + ); memcpy(program + 0 * Instruction.SIZE, instruction_0, Instruction.SIZE); memcpy(program + 1 * Instruction.SIZE, instruction_1, Instruction.SIZE); diff --git a/tests/starkshell/test_starkshell.cairo b/tests/starkshell/test_starkshell.cairo index 8954898..db98590 100644 --- a/tests/starkshell/test_starkshell.cairo +++ b/tests/starkshell/test_starkshell.cairo @@ -82,24 +82,37 @@ func __setup__{ // User1 mints a diamond and adds ERC-1155 and StarkShell let facetCut_len = 2; - tempvar facetCut: FacetCut* = cast(new (FacetCut(ch.erc1155, FacetCutAction.Add), FacetCut(ch.starkshell, FacetCutAction.Add),), FacetCut*); + tempvar facetCut: FacetCut* = cast( + new (FacetCut(ch.erc1155, FacetCutAction.Add), FacetCut(ch.starkshell, FacetCutAction.Add)), + FacetCut*, + ); tempvar fun_returnCalldata = Function(fun_selector_returnCalldata, program_hash, rootDiamond); tempvar fun_setShellFun = Function(fun_selector_setShellFun, setShellFun_hash, rootDiamond); - tempvar fun_invertBoolean = Function(fun_selector_invertBoolean, invertBoolean_hash, rootDiamond); - tempvar fun_interpreteInstruction = Function(fun_selector_interpreteInstruction, interpreteInstruction_hash, rootDiamond); + tempvar fun_invertBoolean = Function( + fun_selector_invertBoolean, invertBoolean_hash, rootDiamond + ); + tempvar fun_interpreteInstruction = Function( + fun_selector_interpreteInstruction, interpreteInstruction_hash, rootDiamond + ); local fun_len = 4; local fun_calldata_size = fun_len * Function.SIZE + 1; tempvar calldata: felt* = new ( - 6, User1, 1, 1, 0, 1, 0, + 6, + User1, + 1, + 1, + 0, + 1, + 0, fun_calldata_size, fun_len, fun_returnCalldata, fun_setShellFun, fun_invertBoolean, fun_interpreteInstruction, - ); + ); let calldata_len = 7 + fun_calldata_size + 1; %{ stop_prank = start_prank(ids.User1, context.rootDiamond) %} @@ -331,7 +344,7 @@ func test_interpreteInstruction_returnCalldata{ input1=Calldata, input2=NULLvar, output=NULLvar, - ); + ); tempvar program = new (instruction0); tempvar memory = new (); @@ -391,14 +404,14 @@ func test_interpreteInstruction_add{ input1=Calldata, input2=NULLvar, output=sumvar, - ); + ); tempvar instruction1 = Instruction( primitive=Primitive(ch.starkshell, return_keyword), input1=sumvar, input2=NULLvar, output=NULLvar, - ); + ); tempvar program = new (instruction0, instruction1); tempvar memory = new (sumvar); @@ -457,14 +470,14 @@ func test_interpreteInstruction_sub{ input1=Calldata, input2=NULLvar, output=subvar, - ); + ); tempvar instruction1 = Instruction( primitive=Primitive(ch.starkshell, return_keyword), input1=subvar, input2=NULLvar, output=NULLvar, - ); + ); tempvar program = new (instruction0, instruction1); tempvar memory = new (subvar); @@ -523,14 +536,14 @@ func test_interpreteInstruction_mul{ input1=Calldata, input2=NULLvar, output=mulvar, - ); + ); tempvar instruction1 = Instruction( primitive=Primitive(ch.starkshell, return_keyword), input1=mulvar, input2=NULLvar, output=NULLvar, - ); + ); tempvar program = new (instruction0, instruction1); tempvar memory = new (mulvar); @@ -589,14 +602,14 @@ func test_interpreteInstruction_div{ input1=Calldata, input2=NULLvar, output=divvar, - ); + ); tempvar instruction1 = Instruction( primitive=Primitive(ch.starkshell, return_keyword), input1=divvar, input2=NULLvar, output=NULLvar, - ); + ); tempvar program = new (instruction0, instruction1); tempvar memory = new (divvar); @@ -655,14 +668,14 @@ func test_interpreteInstruction_emit_events_on_div{ input1=Calldata, input2=NULLvar, output=divvar, - ); + ); tempvar instruction1 = Instruction( primitive=Primitive(ch.starkshell, return_keyword), input1=divvar, input2=NULLvar, output=NULLvar, - ); + ); tempvar program = new (instruction0, instruction1); tempvar memory = new (divvar);