From 6bd26a1f31a80cb9b74f695dd6885994a6855673 Mon Sep 17 00:00:00 2001 From: edwin <102215563+taco-paco@users.noreply.github.com> Date: Mon, 7 Oct 2024 17:44:39 +0900 Subject: [PATCH 1/3] Fix detection of Abi version in contract with only constructor (#1243) * fix: getAbiVersion doesn't work on contracts without any function * fix: getAbiVersion doesn't work on contracts without any function --- .../onlyConstructor/onlyConstructor.cairo | 15 + .../onlyConstructor/onlyConstructor.casm | 1 + .../onlyConstructor.sierra.json | 399 ++++++++++++++++++ __tests__/cairo1.test.ts | 24 +- __tests__/config/fixtures.ts | 6 + __tests__/factories/abi.ts | 7 + __tests__/utils/calldata/cairo.test.ts | 12 +- src/utils/calldata/cairo.ts | 10 +- 8 files changed, 467 insertions(+), 7 deletions(-) create mode 100644 __mocks__/cairo/onlyConstructor/onlyConstructor.cairo create mode 100644 __mocks__/cairo/onlyConstructor/onlyConstructor.casm create mode 100644 __mocks__/cairo/onlyConstructor/onlyConstructor.sierra.json diff --git a/__mocks__/cairo/onlyConstructor/onlyConstructor.cairo b/__mocks__/cairo/onlyConstructor/onlyConstructor.cairo new file mode 100644 index 000000000..bb40042e5 --- /dev/null +++ b/__mocks__/cairo/onlyConstructor/onlyConstructor.cairo @@ -0,0 +1,15 @@ +#[starknet::contract] +pub mod OnlyConstructor { + use starknet::ContractAddress; + use starknet::storage::Map; + + #[storage] + struct Storage { + names: Map::, + } + + #[constructor] + fn constructor(ref self: ContractState, name: felt252, address: ContractAddress) { + self.names.write(address, name); + } +} diff --git a/__mocks__/cairo/onlyConstructor/onlyConstructor.casm b/__mocks__/cairo/onlyConstructor/onlyConstructor.casm new file mode 100644 index 000000000..2438f2104 --- /dev/null +++ b/__mocks__/cairo/onlyConstructor/onlyConstructor.casm @@ -0,0 +1 @@ +{"prime":"0x800000000000011000000000000000000000000000000000000000000000001","compiler_version":"2.8.2","bytecode":["0xa0680017fff8000","0x7","0x482680017ffa8000","0x100000000000000000000000000000000","0x400280007ff97fff","0x10780017fff7fff","0xec","0x4825800180007ffa","0x0","0x400280007ff97fff","0x482680017ff98000","0x1","0x48297ffc80007ffd","0x20680017fff7fff","0x4","0x10780017fff7fff","0xa","0x482680017ffc8000","0x1","0x480a7ffd7fff8000","0x480680017fff8000","0x0","0x480280007ffc8000","0x10780017fff7fff","0x8","0x480a7ffc7fff8000","0x480a7ffd7fff8000","0x480680017fff8000","0x1","0x480680017fff8000","0x0","0x20680017fff7ffe","0xc3","0x48307ffc80007ffd","0x20680017fff7fff","0x4","0x10780017fff7fff","0xa","0x482480017ffb8000","0x1","0x48127ffb7fff8000","0x480680017fff8000","0x0","0x480080007ff88000","0x10780017fff7fff","0x8","0x48127ffb7fff8000","0x48127ffb7fff8000","0x480680017fff8000","0x1","0x480680017fff8000","0x0","0x20680017fff7ffe","0x9c","0xa0680017fff8004","0xe","0x4824800180047ffe","0x800000000000000000000000000000000000000000000000000000000000000","0x484480017ffe8000","0x110000000000000000","0x48307ffe7fff8002","0x480080007ff17ffc","0x480080017ff07ffc","0x402480017ffb7ffd","0xffffffffffffffeeffffffffffffffff","0x400080027fef7ffd","0x10780017fff7fff","0x8a","0x484480017fff8001","0x8000000000000000000000000000000","0x48307fff80007ffd","0x480080007ff27ffd","0x480080017ff17ffd","0x402480017ffc7ffe","0xf8000000000000000000000000000000","0x400080027ff07ffe","0x482480017ff08000","0x3","0x48307ff680007ff7","0x20680017fff7fff","0x4","0x10780017fff7fff","0x11","0x40780017fff7fff","0x1","0x480680017fff8000","0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473","0x400080007ffe7fff","0x480a7ff87fff8000","0x48127ffb7fff8000","0x48127fe97fff8000","0x480a7ffb7fff8000","0x480680017fff8000","0x1","0x48127ff97fff8000","0x482480017ff88000","0x1","0x208b7fff7fff7ffe","0x1104800180018000","0x9f","0x482480017fff8000","0x9e","0x480080007fff8000","0x480080007fff8000","0x482480017fff8000","0x1eb4","0xa0680017fff8000","0x8","0x48307ffe80007fe6","0x482480017fff8000","0x100000000000000000000000000000000","0x400080007ff57fff","0x10780017fff7fff","0x4c","0x48307ffe80007fe6","0x400080007ff67fff","0x480680017fff8000","0x968a09a4841848cf6a616f8edef20d474b416f4e8fa338d2c6ff1c1b7cda16","0x400280007ff87fff","0x400280017ff87fef","0x480280027ff88000","0xa0680017fff8005","0xe","0x4824800180057ffe","0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00","0x484480017ffe8000","0x110000000000000000","0x48307ffe7fff8003","0x480080017ff07ffc","0x480080027fef7ffc","0x482480017ffb7ffd","0xffffffffffffffeefffffffffffffeff","0x400080037fed7ffc","0x10780017fff7fff","0x11","0x48127ffe7fff8005","0x484480017ffe8000","0x8000000000000000000000000000000","0x48307ffe7fff8003","0x480080017ff07ffd","0x482480017ffc7ffe","0xf0000000000000000000000000000100","0x480080027fee7ffd","0x400080037fed7ff9","0x402480017ffd7ff9","0xffffffffffffffffffffffffffffffff","0x20680017fff7ffd","0x4","0x402780017fff7fff","0x1","0x480680017fff8000","0x0","0x482680017ff88000","0x3","0x482480017feb8000","0x4","0x480680017fff8000","0x53746f726167655772697465","0x400280007ffb7fff","0x400280017ffb7ff2","0x400280027ffb7ffc","0x400280037ffb7ffb","0x400280047ffb7fde","0x480280067ffb8000","0x20680017fff7fff","0xe","0x40780017fff7fff","0x1","0x48127ffb7fff8000","0x48127ffb7fff8000","0x480280057ffb8000","0x482680017ffb8000","0x7","0x480680017fff8000","0x0","0x48127ffa7fff8000","0x48127ff97fff8000","0x208b7fff7fff7ffe","0x48127ffc7fff8000","0x48127ffc7fff8000","0x480280057ffb8000","0x482680017ffb8000","0x9","0x480680017fff8000","0x1","0x480280077ffb8000","0x480280087ffb8000","0x208b7fff7fff7ffe","0x40780017fff7fff","0x1","0x480680017fff8000","0x4f7574206f6620676173","0x400080007ffe7fff","0x480a7ff87fff8000","0x482480017ff28000","0x1","0x48127fe07fff8000","0x480a7ffb7fff8000","0x480680017fff8000","0x1","0x48127ff97fff8000","0x482480017ff88000","0x1","0x208b7fff7fff7ffe","0x482480017fef8000","0x3","0x10780017fff7fff","0x5","0x40780017fff7fff","0x6","0x48127fef7fff8000","0x40780017fff7fff","0x1","0x480680017fff8000","0x4661696c656420746f20646573657269616c697a6520706172616d202332","0x400080007ffe7fff","0x480a7ff87fff8000","0x48127ffc7fff8000","0x48127fe97fff8000","0x480a7ffb7fff8000","0x480680017fff8000","0x1","0x48127ff97fff8000","0x482480017ff88000","0x1","0x208b7fff7fff7ffe","0x40780017fff7fff","0x1","0x480680017fff8000","0x4661696c656420746f20646573657269616c697a6520706172616d202331","0x400080007ffe7fff","0x480a7ff87fff8000","0x48127ff77fff8000","0x48127ff57fff8000","0x480a7ffb7fff8000","0x480680017fff8000","0x1","0x48127ff97fff8000","0x482480017ff88000","0x1","0x208b7fff7fff7ffe","0x40780017fff7fff","0x1","0x480680017fff8000","0x4f7574206f6620676173","0x400080007ffe7fff","0x480a7ff87fff8000","0x482680017ff98000","0x1","0x480a7ffa7fff8000","0x480a7ffb7fff8000","0x480680017fff8000","0x1","0x48127ff97fff8000","0x482480017ff88000","0x1","0x208b7fff7fff7ffe"],"bytecode_segment_lengths":[257],"hints":[[0,[{"TestLessThanOrEqual":{"lhs":{"Immediate":"0x0"},"rhs":{"Deref":{"register":"FP","offset":-6}},"dst":{"register":"AP","offset":0}}}]],[54,[{"TestLessThan":{"lhs":{"Deref":{"register":"AP","offset":-1}},"rhs":{"Immediate":"0x800000000000000000000000000000000000000000000000000000000000000"},"dst":{"register":"AP","offset":4}}}]],[58,[{"LinearSplit":{"value":{"Deref":{"register":"AP","offset":3}},"scalar":{"Immediate":"0x110000000000000000"},"max_x":{"Immediate":"0xffffffffffffffffffffffffffffffff"},"x":{"register":"AP","offset":-2},"y":{"register":"AP","offset":-1}}}]],[68,[{"LinearSplit":{"value":{"Deref":{"register":"AP","offset":-2}},"scalar":{"Immediate":"0x8000000000000000000000000000000"},"max_x":{"Immediate":"0xffffffffffffffffffffffffffffffff"},"x":{"register":"AP","offset":-1},"y":{"register":"AP","offset":0}}}]],[83,[{"AllocSegment":{"dst":{"register":"AP","offset":0}}}]],[106,[{"TestLessThanOrEqual":{"lhs":{"Deref":{"register":"AP","offset":-1}},"rhs":{"Deref":{"register":"AP","offset":-25}},"dst":{"register":"AP","offset":0}}}]],[121,[{"TestLessThan":{"lhs":{"Deref":{"register":"AP","offset":-1}},"rhs":{"Immediate":"0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00"},"dst":{"register":"AP","offset":5}}}]],[125,[{"LinearSplit":{"value":{"Deref":{"register":"AP","offset":4}},"scalar":{"Immediate":"0x110000000000000000"},"max_x":{"Immediate":"0xffffffffffffffffffffffffffffffff"},"x":{"register":"AP","offset":-2},"y":{"register":"AP","offset":-1}}}]],[136,[{"LinearSplit":{"value":{"Deref":{"register":"AP","offset":4}},"scalar":{"Immediate":"0x8000000000000000000000000000000"},"max_x":{"Immediate":"0xfffffffffffffffffffffffffffffffe"},"x":{"register":"AP","offset":-2},"y":{"register":"AP","offset":-1}}}]],[163,[{"SystemCall":{"system":{"Deref":{"register":"FP","offset":-5}}}}]],[166,[{"AllocSegment":{"dst":{"register":"AP","offset":0}}}]],[188,[{"AllocSegment":{"dst":{"register":"AP","offset":0}}}]],[211,[{"AllocSegment":{"dst":{"register":"AP","offset":0}}}]],[226,[{"AllocSegment":{"dst":{"register":"AP","offset":0}}}]],[241,[{"AllocSegment":{"dst":{"register":"AP","offset":0}}}]]],"entry_points_by_type":{"EXTERNAL":[],"L1_HANDLER":[],"CONSTRUCTOR":[{"selector":"0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194","offset":0,"builtins":["pedersen","range_check"]}]}} \ No newline at end of file diff --git a/__mocks__/cairo/onlyConstructor/onlyConstructor.sierra.json b/__mocks__/cairo/onlyConstructor/onlyConstructor.sierra.json new file mode 100644 index 000000000..b275b8728 --- /dev/null +++ b/__mocks__/cairo/onlyConstructor/onlyConstructor.sierra.json @@ -0,0 +1,399 @@ +{ + "sierra_program": [ + "0x1", + "0x6", + "0x0", + "0x2", + "0x8", + "0x2", + "0xae", + "0x52", + "0x1b", + "0x52616e6765436865636b", + "0x800000000000000100000000000000000000000000000000", + "0x436f6e7374", + "0x800000000000000000000000000000000000000000000002", + "0x1", + "0xc", + "0x2", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x4f7574206f6620676173", + "0x4172726179", + "0x800000000000000300000000000000000000000000000001", + "0x536e617073686f74", + "0x800000000000000700000000000000000000000000000001", + "0x4", + "0x537472756374", + "0x800000000000000700000000000000000000000000000002", + "0x0", + "0x1baeba72e79e9db2587cf44fedb2f3700b2075a5e8e39a562584862c4b71f62", + "0x5", + "0x2ee1e2b1b89f8c495f200e4956278a4d47395fe262f27b52e5865c9524c08c3", + "0x6", + "0x9", + "0x753332", + "0x800000000000000700000000000000000000000000000000", + "0x53746f7261676541646472657373", + "0x53746f726167654261736541646472657373", + "0x66656c74323532", + "0x3f3c5f6678e8adc54edf446ed6e5633dd551707921221d95b17c3569cb79a", + "0x968a09a4841848cf6a616f8edef20d474b416f4e8fa338d2c6ff1c1b7cda16", + "0x4275696c74696e436f737473", + "0x53797374656d", + "0x506564657273656e", + "0x800000000000000f00000000000000000000000000000001", + "0x16a4c8d7c05909052238a862d8cc3e7975bf05a07b3a69c6b28951083a6d672", + "0x800000000000000300000000000000000000000000000003", + "0x12", + "0x456e756d", + "0x9931c641b913035ae674b400b61a51476d506bbe8bba2ff8a6272790aba9e6", + "0x7", + "0x13", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x436f6e747261637441646472657373", + "0x800000000000000700000000000000000000000000000003", + "0x11c6d8087e00642489f92d2821ad6ebd6532ad1a3b6d12833da6d6810391511", + "0x17", + "0x426f78", + "0x4761734275696c74696e", + "0x3a", + "0x7265766f6b655f61705f747261636b696e67", + "0x77697468647261775f676173", + "0x6272616e63685f616c69676e", + "0x7374727563745f6465636f6e737472756374", + "0x656e61626c655f61705f747261636b696e67", + "0x73746f72655f74656d70", + "0x61727261795f736e617073686f745f706f705f66726f6e74", + "0x756e626f78", + "0x72656e616d65", + "0x656e756d5f696e6974", + "0x18", + "0x6a756d70", + "0x7374727563745f636f6e737472756374", + "0x656e756d5f6d61746368", + "0x21adb5788e32c84f69a1863d85ef9394b7bf761a0ce1190f826984e5075c371", + "0x64697361626c655f61705f747261636b696e67", + "0x64726f70", + "0x19", + "0x16", + "0x61727261795f6e6577", + "0x636f6e73745f61735f696d6d656469617465", + "0x15", + "0x61727261795f617070656e64", + "0x14", + "0x11", + "0x1a", + "0x10", + "0x6765745f6275696c74696e5f636f737473", + "0xf", + "0x77697468647261775f6761735f616c6c", + "0x636f6e74726163745f616464726573735f746f5f66656c74323532", + "0xe", + "0xd", + "0x736e617073686f745f74616b65", + "0x706564657273656e", + "0xad292db4ff05a993c318438c1b6c8a8303266af2da151aa28ccece6726f1f1", + "0x73746f726167655f616464726573735f66726f6d5f62617365", + "0x8", + "0x73746f726167655f77726974655f73797363616c6c", + "0x3", + "0xb3", + "0xffffffffffffffff", + "0xa4", + "0xa", + "0xb", + "0x93", + "0x1d", + "0x1c", + "0x22", + "0x1e", + "0x1f", + "0x20", + "0x80", + "0x21", + "0x23", + "0x7b", + "0x24", + "0x25", + "0x26", + "0x3b", + "0x27", + "0x28", + "0x29", + "0x2a", + "0x2b", + "0x2c", + "0x2d", + "0x2e", + "0x2f", + "0x30", + "0x6a", + "0x31", + "0x32", + "0x33", + "0x34", + "0x35", + "0x36", + "0x37", + "0x38", + "0x39", + "0x3c", + "0x3d", + "0x3e", + "0x3f", + "0x40", + "0x41", + "0x60", + "0x42", + "0x43", + "0x44", + "0x45", + "0x46", + "0x47", + "0x48", + "0x49", + "0x4a", + "0x4b", + "0x4c", + "0x4d", + "0x4e", + "0x4f", + "0x50", + "0x51", + "0x52", + "0x53", + "0x54", + "0x85", + "0x55", + "0x56", + "0x57", + "0x58", + "0x59", + "0x5a", + "0x5b", + "0x5c", + "0x5d", + "0x5e", + "0x5f", + "0x61", + "0x62", + "0x63", + "0x64", + "0x65", + "0x66", + "0x6d2", + "0x11100f050e0d06050c0b0a0706050403090706050403080706050403020100", + "0x306051d121110191c191b191a191812071705040316051512111014051312", + "0x29052805271224260f052505151224102312221002210220191f1e07060504", + "0x1233123231023006050e2f2e0506052d122c2615122210192b2a0706050403", + "0x3712073c05073b0605053a0605053906050538120505371236160505351234", + "0x14050542124112403c05053f05073c05073b2e05053e123d3c050537140505", + "0x5053e06050548060505374705054606050545060505424405054243050542", + "0x537124d490505374c0505374b0505374a05053705074905073b2905053e25", + "0x56125512545205053552050542520505535205053e510505461250124f4e05", + "0x4905073b2805053e1605053e0f0505420f0505531258170505375705054612", + "0x512125b051212125a1605054205050546070505462e050542590505461207", + "0x5b05120f1217055b050f055912125b051207125728075c1614075b07070507", + "0x5e052812125b051207120605515e5d075b071705161214055b051405141212", + "0x55e124c055b055d055d124e055b055105171251055b055205571252055b05", + "0x55b052505511225055b05125212125b051207121229051206124a055b054e", + "0x12071247055f49055b074a054e124a055b0529055e124c055b0506055d1229", + "0x571243055b052e052812125b051207123c05602e44075b074c051612125b05", + "0x1260055b0500055e1261055b0544055d1200055b054b0517124b055b054305", + "0x53c055d1264055b056305511263055b05125212125b051207121262051206", + "0x74c12125b0512071267056665055b0760054e1260055b0564055e1261055b", + "0x75b076105161262055b0562051412125b051207126a05696862075b076514", + "0x125b056c052912125b056b052512125b05124a12125b051207126e056d6c6b", + "0x53c1270055b05122e126f055b05124412125b0549054712125b0568054912", + "0x1273055b05717207001272055b05124b1271055b05706f07431270055b0570", + "0x16055b051605631262055b056205141212055b051205601274055b05730561", + "0x2512125b051207127459166212140574055b057405651259055b0559056412", + "0x7776075b0775166259681275055b057505621275055b05126712125b056e05", + "0x7c055b05126b127b055b0568056a12125b05124a12125b051207127a790778", + "0x55b057f057012125b057e056f127f7e075b057d056e127d055b057c056c12", + "0x53c126d31075b057b811259711281055b0581053c1281055b058005571280", + "0x1285055b0512741284055b05830573128382075b056d760772126d055b056d", + "0x498485597714761282055b058205141231055b053105601285055b05850575", + "0x8d075b058c0577128c055b05124412125b051207128b8a8959888786075b07", + "0x55b0590057c1290055b058f057b128f055b058e057a12125b058d0579128e", + "0x5b058705641286055b058605631282055b058205141231055b053105601291", + "0x1292055b05124b12125b051207129187868231140591055b05910565128705", + "0x55b058205141231055b053105601294055b059305611293055b058b920700", + "0x8a898231140594055b05940565128a055b058a05641289055b058905631282", + "0x5124412125b0549054712125b0568054912125b05124a12125b0512071294", + "0x5124b1297055b05969507431296055b0596053c1296055b05127d1295055b", + "0x5141212055b05120560129a055b059905611299055b05979807001298055b", + "0x14059a055b059a05651259055b05590564127a055b057a05631279055b0579", + "0x5b056a051412125b0549054712125b0561052512125b051207129a597a7912", + "0x54712125b0561052512125b0567057e12125b05120712129c051206129b05", + "0x55b05127f129d055b05124412125b05124a129b055b0514051412125b0549", + "0x59fa0070012a0055b05124b129f055b059e9d0743129e055b059e053c129e", + "0x160563129b055b059b05141212055b0512056012a2055b05a1056112a1055b", + "0x5120712a259169b121405a2055b05a205651259055b055905641216055b05", + "0x8012a3055b05124412125b054c052512125b0547057e12125b05124a12125b", + "0x12a6055b05124b12a5055b05a4a3074312a4055b05a4053c12a4055b0512", + "0x14055b051405141212055b051205601288055b05a7056112a7055b05a5a607", + "0x8859161412140588055b058805651259055b055905641216055b0516056312", + "0xa9053c12a9055b05127d12a8055b05124412125b050f058112125b05120712", + "0x6112ac055b05aaab070012ab055b05124b12aa055b05a9a8074312a9055b05", + "0x1257055b055705631228055b052805141212055b0512056012ad055b05ac05", + "0x4a14164c4b124a1405ad595728121405ad055b05ad05651259055b05590564", + "0x120f59070512494c4b12" + ], + "sierra_program_debug_info": { + "type_names": [ + [0, "RangeCheck"], + [ + 1, + "Const" + ], + [ + 2, + "Const" + ], + [3, "Const"], + [4, "Array"], + [5, "Snapshot>"], + [6, "core::array::Span::"], + [7, "Tuple>"], + [8, "Const"], + [9, "u32"], + [10, "StorageAddress"], + [11, "StorageBaseAddress"], + [12, "felt252"], + [ + 13, + "core::starknet::storage::storage_base::StorageBase::>>" + ], + [ + 14, + "Const" + ], + [15, "BuiltinCosts"], + [16, "System"], + [17, "Pedersen"], + [18, "core::panics::Panic"], + [19, "Tuple>"], + [20, "core::panics::PanicResult::<(core::array::Span::,)>"], + [21, "Const"], + [22, "ContractAddress"], + [23, "Unit"], + [24, "core::option::Option::"], + [25, "Box"], + [26, "GasBuiltin"] + ], + "libfunc_names": [ + [0, "revoke_ap_tracking"], + [1, "withdraw_gas"], + [2, "branch_align"], + [3, "struct_deconstruct>"], + [4, "enable_ap_tracking"], + [5, "store_temp"], + [6, "array_snapshot_pop_front"], + [7, "unbox"], + [8, "rename"], + [9, "enum_init, 0>"], + [10, "store_temp>>"], + [11, "store_temp>"], + [12, "jump"], + [13, "struct_construct"], + [14, "enum_init, 1>"], + [15, "enum_match>"], + [16, "contract_address_try_from_felt252"], + [17, "disable_ap_tracking"], + [18, "drop>>"], + [19, "drop>"], + [20, "drop"], + [21, "drop"], + [22, "array_new"], + [ + 23, + "const_as_immediate>" + ], + [24, "store_temp"], + [25, "array_append"], + [26, "struct_construct"], + [27, "struct_construct>>"], + [28, "enum_init,)>, 1>"], + [29, "store_temp"], + [30, "store_temp"], + [31, "store_temp"], + [32, "store_temp,)>>"], + [33, "get_builtin_costs"], + [34, "store_temp"], + [35, "withdraw_gas_all"], + [36, "contract_address_to_felt252"], + [ + 37, + "const_as_immediate>" + ], + [ + 38, + "struct_construct>>>" + ], + [ + 39, + "snapshot_take>>>" + ], + [ + 40, + "drop>>>" + ], + [ + 41, + "struct_deconstruct>>>" + ], + [42, "pedersen"], + [43, "storage_base_address_from_felt252"], + [44, "storage_address_from_base"], + [45, "const_as_immediate>"], + [46, "store_temp"], + [47, "storage_write_syscall"], + [48, "snapshot_take>"], + [49, "drop>"], + [50, "struct_construct>"], + [51, "struct_construct>>"], + [52, "enum_init,)>, 0>"], + [53, "const_as_immediate>"], + [54, "drop"], + [ + 55, + "const_as_immediate>" + ], + [ + 56, + "const_as_immediate>" + ], + [57, "drop>"] + ], + "user_func_names": [[0, "starknet_hello_world::OnlyConstructor::__wrapper__constructor"]] + }, + "contract_class_version": "0.1.0", + "entry_points_by_type": { + "EXTERNAL": [], + "L1_HANDLER": [], + "CONSTRUCTOR": [ + { + "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194", + "function_idx": 0 + } + ] + }, + "abi": [ + { + "type": "constructor", + "name": "constructor", + "inputs": [ + { "name": "name", "type": "core::felt252" }, + { "name": "address", "type": "core::starknet::contract_address::ContractAddress" } + ] + }, + { + "type": "event", + "name": "starknet_hello_world::OnlyConstructor::Event", + "kind": "enum", + "variants": [] + } + ] +} diff --git a/__tests__/cairo1.test.ts b/__tests__/cairo1.test.ts index 20f636226..9fdd55fdb 100644 --- a/__tests__/cairo1.test.ts +++ b/__tests__/cairo1.test.ts @@ -24,6 +24,8 @@ import { compiledComplexSierra, compiledHelloSierra, compiledHelloSierraCasm, + compiledOnlyConstructorSierra, + compiledOnlyConstructorCasm, describeIfDevnet, getTestAccount, getTestProvider, @@ -40,6 +42,7 @@ describeIfDevnet('Cairo 1 Devnet', () => { const account = getTestAccount(provider); let dd: DeclareDeployUDCResponse; let cairo1Contract: Contract; + let onlyConstructorContract: Contract; initializeMatcher(expect); beforeAll(async () => { @@ -49,6 +52,18 @@ describeIfDevnet('Cairo 1 Devnet', () => { }); cairo1Contract = new Contract(compiledHelloSierra.abi, dd.deploy.contract_address, account); + + const ddOnlyConstructor = await account.declareAndDeploy({ + contract: compiledOnlyConstructorSierra, + casm: compiledOnlyConstructorCasm, + constructorCalldata: [101, account.address], + }); + + onlyConstructorContract = new Contract( + compiledOnlyConstructorSierra.abi, + ddOnlyConstructor.deploy.contract_address, + account + ); }); test('Declare & deploy v2 - Hello Cairo 1 contract', async () => { @@ -105,9 +120,14 @@ describeIfDevnet('Cairo 1 Devnet', () => { }); test('isCairo1', async () => { - const isContractCairo1 = cairo1Contract.isCairo1(); + let isContractCairo1 = cairo1Contract.isCairo1(); + expect(isContractCairo1).toBe(true); + let isAbiCairo1 = isCairo1Abi(cairo1Contract.abi); + expect(isAbiCairo1).toBe(true); + + isContractCairo1 = onlyConstructorContract.isCairo1(); expect(isContractCairo1).toBe(true); - const isAbiCairo1 = isCairo1Abi(cairo1Contract.abi); + isAbiCairo1 = isCairo1Abi(onlyConstructorContract.abi); expect(isAbiCairo1).toBe(true); }); diff --git a/__tests__/config/fixtures.ts b/__tests__/config/fixtures.ts index 818472344..80cd73c25 100644 --- a/__tests__/config/fixtures.ts +++ b/__tests__/config/fixtures.ts @@ -80,6 +80,12 @@ export const compiledSidMulticall = readContractSierra('starknetId/multicall/mul export const compiledSidMulticallCasm = readContractSierraCasm('starknetId/multicall/multicall'); export const compiledNonZero = readContractSierra('cairo/cairo263/zeroable.sierra'); export const compiledNonZeroCasm = readContractSierraCasm('cairo/cairo263/zeroable'); +export const compiledOnlyConstructorSierra = readContractSierra( + 'cairo/onlyConstructor/onlyConstructor.sierra' +); +export const compiledOnlyConstructorCasm = readContractSierraCasm( + 'cairo/onlyConstructor/onlyConstructor' +); export function getTestProvider( isProvider?: true, diff --git a/__tests__/factories/abi.ts b/__tests__/factories/abi.ts index 84a6d42d3..f2492fca0 100644 --- a/__tests__/factories/abi.ts +++ b/__tests__/factories/abi.ts @@ -10,6 +10,13 @@ export const getFunctionAbi = (inputsType: string): FunctionAbi => ({ type: 'function', }); +export const getConstructorAbi = (inputsType: string): FunctionAbi => ({ + inputs: [getAbiEntry(inputsType)], + name: 'test', + outputs: [getAbiEntry(inputsType)], + type: 'constructor', +}); + export const getInterfaceAbi = (functionAbiType: string = 'struct'): InterfaceAbi => ({ items: [getFunctionAbi(functionAbiType)], name: 'test_interface_abi', diff --git a/__tests__/utils/calldata/cairo.test.ts b/__tests__/utils/calldata/cairo.test.ts index 2c43cda3e..4b7aaf7f7 100644 --- a/__tests__/utils/calldata/cairo.test.ts +++ b/__tests__/utils/calldata/cairo.test.ts @@ -28,7 +28,13 @@ import { felt, } from '../../../src/utils/calldata/cairo'; import { ETH_ADDRESS, Literal, Uint, type ContractVersion, NON_ZERO_PREFIX } from '../../../src'; -import { getFunctionAbi, getAbiEnums, getAbiStructs, getInterfaceAbi } from '../../factories/abi'; +import { + getFunctionAbi, + getAbiEnums, + getAbiStructs, + getInterfaceAbi, + getConstructorAbi, +} from '../../factories/abi'; describe('isLen', () => { test('should return true if name ends with "_len"', () => { @@ -254,6 +260,10 @@ describe('isCairo1Abi', () => { expect(isCairo1Abi([getFunctionAbi('felt')])).toEqual(false); }); + test('should return false if ABI comes from Cairo 0 contract', () => { + expect(isCairo1Abi([getConstructorAbi('felt')])).toEqual(false); + }); + test('should throw an error if ABI does not come from Cairo 1 contract ', () => { expect(() => isCairo1Abi([{}])).toThrow(new Error('Unable to determine Cairo version')); }); diff --git a/src/utils/calldata/cairo.ts b/src/utils/calldata/cairo.ts index 88ca11801..253db4055 100644 --- a/src/utils/calldata/cairo.ts +++ b/src/utils/calldata/cairo.ts @@ -203,14 +203,16 @@ export function getAbiContractVersion(abi: Abi): ContractVersion { // determine by function io types "Cairo 1.1" or "Cairo 0.0" // find first function with inputs or outputs - const testFunction = abi.find( - (it) => it.type === 'function' && (it.inputs.length || it.outputs.length) + const testSubject = abi.find( + (it) => + (it.type === 'function' || it.type === 'constructor') && + (it.inputs.length || it.outputs.length) ); - if (!testFunction) { + if (!testSubject) { return { cairo: undefined, compiler: undefined }; } - const io = testFunction.inputs.length ? testFunction.inputs : testFunction.outputs; + const io = testSubject.inputs.length ? testSubject.inputs : testSubject.outputs; if (isCairo1Type(io[0].type)) { return { cairo: '1', compiler: '1' }; } From d8639e57d223e3b26ed4ac5a6076d62e50040e4c Mon Sep 17 00:00:00 2001 From: Petar Penovic Date: Fri, 23 Aug 2024 14:10:12 +0200 Subject: [PATCH 2/3] test: reorganize compiled contract handling --- ...t040.json => accountArgent040.sierra.json} | 0 ...untOZ080.json => accountOZ080.sierra.json} | 0 .../hash/{hash.json => hash.sierra.json} | 0 .../{compiled.json => compiled.sierra.json} | 0 .../{hello.json => hello.sierra.json} | 0 __tests__/account.outsideExecution.test.ts | 28 ++-- __tests__/account.starknetId.test.ts | 22 ++- __tests__/account.test.ts | 12 +- __tests__/cairo1.test.ts | 16 ++- __tests__/cairo1v2.test.ts | 23 ++- __tests__/cairo1v2_typed.test.ts | 25 ++-- __tests__/cairov24onward.test.ts | 26 ++-- __tests__/config/fixtures.ts | 133 ++++++++---------- __tests__/contract.test.ts | 15 +- __tests__/defaultProvider.test.ts | 4 +- __tests__/rpcProvider.test.ts | 12 +- __tests__/transactionReceipt.test.ts | 10 +- __tests__/utils/classHash.test.ts | 17 ++- __tests__/utils/contract.test.ts | 6 +- __tests__/utils/ethSigner.test.ts | 20 +-- __tests__/utils/secp256k1Point.test.ts | 5 +- __tests__/utils/stark.browser.test.ts | 4 +- __tests__/utils/stark.test.ts | 4 +- 23 files changed, 186 insertions(+), 196 deletions(-) rename __mocks__/cairo/account/{accountArgent040.json => accountArgent040.sierra.json} (100%) rename __mocks__/cairo/account/{accountOZ080.json => accountOZ080.sierra.json} (100%) rename __mocks__/cairo/hash/{hash.json => hash.sierra.json} (100%) rename __mocks__/cairo/helloCairo2/{compiled.json => compiled.sierra.json} (100%) rename __mocks__/cairo/helloSierra/{hello.json => hello.sierra.json} (100%) diff --git a/__mocks__/cairo/account/accountArgent040.json b/__mocks__/cairo/account/accountArgent040.sierra.json similarity index 100% rename from __mocks__/cairo/account/accountArgent040.json rename to __mocks__/cairo/account/accountArgent040.sierra.json diff --git a/__mocks__/cairo/account/accountOZ080.json b/__mocks__/cairo/account/accountOZ080.sierra.json similarity index 100% rename from __mocks__/cairo/account/accountOZ080.json rename to __mocks__/cairo/account/accountOZ080.sierra.json diff --git a/__mocks__/cairo/hash/hash.json b/__mocks__/cairo/hash/hash.sierra.json similarity index 100% rename from __mocks__/cairo/hash/hash.json rename to __mocks__/cairo/hash/hash.sierra.json diff --git a/__mocks__/cairo/helloCairo2/compiled.json b/__mocks__/cairo/helloCairo2/compiled.sierra.json similarity index 100% rename from __mocks__/cairo/helloCairo2/compiled.json rename to __mocks__/cairo/helloCairo2/compiled.sierra.json diff --git a/__mocks__/cairo/helloSierra/hello.json b/__mocks__/cairo/helloSierra/hello.sierra.json similarity index 100% rename from __mocks__/cairo/helloSierra/hello.json rename to __mocks__/cairo/helloSierra/hello.sierra.json diff --git a/__tests__/account.outsideExecution.test.ts b/__tests__/account.outsideExecution.test.ts index d7c758932..15010a53f 100644 --- a/__tests__/account.outsideExecution.test.ts +++ b/__tests__/account.outsideExecution.test.ts @@ -1,34 +1,32 @@ // We test here the most common case: an account compatible with ERC-165 and SNIP-9 (v2). // To limit test duration, these cases are not tested: non ERC165 account, non SNIP-9 account, SNIP9-v1 account. import { - Provider, Account, cairo, - ec, - stark, CairoCustomEnum, CairoOption, CairoOptionVariant, CallData, - OutsideExecutionVersion, - type OutsideExecutionOptions, - type OutsideTransaction, constants, - type Call, Contract, + ec, outsideExecution, - type TypedData, - type Calldata, + OutsideExecutionVersion, + Provider, src5, + stark, + type Call, + type Calldata, + type OutsideExecutionOptions, + type OutsideTransaction, + type TypedData, } from '../src'; import { getSelectorFromName } from '../src/utils/hash'; import { getDecimalString } from '../src/utils/num'; -import { - compiledArgentX4Account, - compiledErc20OZ, - getTestAccount, - getTestProvider, -} from './config/fixtures'; +import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; + +const compiledErc20OZ = contracts.Erc20OZ.sierra; +const compiledArgentX4Account = contracts.ArgentX4Account.sierra; describe('Account and OutsideExecution', () => { const ethAddress = '0x49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7'; diff --git a/__tests__/account.starknetId.test.ts b/__tests__/account.starknetId.test.ts index 6c08eb19e..b7acc3bcb 100644 --- a/__tests__/account.starknetId.test.ts +++ b/__tests__/account.starknetId.test.ts @@ -1,19 +1,17 @@ import { Provider, num, shortString } from '../src'; -import { - compiledNaming, - compiledNamingCasm, - compiledPricing, - compiledPricingCasm, - compiledSidMulticall, - compiledSidMulticallCasm, - compiledStarknetId, - compiledStarknetIdCasm, - getTestAccount, - getTestProvider, -} from './config/fixtures'; +import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; const { hexToDecimalString } = num; +const compiledNaming = contracts.starknetId.Naming.sierra; +const compiledNamingCasm = contracts.starknetId.Naming.casm; +const compiledPricing = contracts.starknetId.Pricing.sierra; +const compiledPricingCasm = contracts.starknetId.Pricing.casm; +const compiledSidMulticall = contracts.starknetId.SidMulticall.sierra; +const compiledSidMulticallCasm = contracts.starknetId.SidMulticall.casm; +const compiledStarknetId = contracts.starknetId.StarknetId.sierra; +const compiledStarknetIdCasm = contracts.starknetId.StarknetId.casm; + describe('deploy and test Wallet', () => { const provider = new Provider(getTestProvider()); const account = getTestAccount(provider); diff --git a/__tests__/account.test.ts b/__tests__/account.test.ts index 257ec9ce1..20a0369e8 100644 --- a/__tests__/account.test.ts +++ b/__tests__/account.test.ts @@ -20,11 +20,7 @@ import { } from '../src'; import { TEST_TX_VERSION, - compiledErc20, - compiledHelloSierra, - compiledHelloSierraCasm, - compiledOpenZeppelinAccount, - compiledTestDapp, + contracts, describeIfDevnet, erc20ClassHash, getTestAccount, @@ -38,6 +34,12 @@ const { randomAddress } = stark; const { uint256 } = cairo; const { Signature } = ec.starkCurve; +const compiledErc20 = contracts.Erc20; +const compiledOpenZeppelinAccount = contracts.OpenZeppelinAccount; +const compiledTestDapp = contracts.TestDapp; +const compiledHelloSierra = contracts.HelloSierra.sierra; +const compiledHelloSierraCasm = contracts.HelloSierra.casm; + describe('deploy and test Wallet', () => { const provider = new Provider(getTestProvider()); const account = getTestAccount(provider); diff --git a/__tests__/cairo1.test.ts b/__tests__/cairo1.test.ts index 9fdd55fdb..ad2c4df6e 100644 --- a/__tests__/cairo1.test.ts +++ b/__tests__/cairo1.test.ts @@ -19,13 +19,7 @@ import { } from '../src'; import { TEST_TX_VERSION, - compiledC1Account, - compiledC1AccountCasm, - compiledComplexSierra, - compiledHelloSierra, - compiledHelloSierraCasm, - compiledOnlyConstructorSierra, - compiledOnlyConstructorCasm, + contracts, describeIfDevnet, getTestAccount, getTestProvider, @@ -36,6 +30,14 @@ const { uint256, tuple, isCairo1Abi } = cairo; const { toHex } = num; const { starknetKeccak } = selector; +const compiledComplexSierra = contracts.ComplexSierra; +const compiledC1Account = contracts.C1Account.sierra; +const compiledC1AccountCasm = contracts.C1Account.casm; +const compiledHelloSierra = contracts.HelloSierra.sierra; +const compiledHelloSierraCasm = contracts.HelloSierra.casm; +const compiledOnlyConstructorSierra = contracts.OnlyConstructor.sierra; +const compiledOnlyConstructorCasm = contracts.OnlyConstructor.casm; + describeIfDevnet('Cairo 1 Devnet', () => { describe('API & Contract interactions', () => { const provider = getTestProvider(); diff --git a/__tests__/cairo1v2.test.ts b/__tests__/cairo1v2.test.ts index 2d07555f4..0aa09fbe9 100644 --- a/__tests__/cairo1v2.test.ts +++ b/__tests__/cairo1v2.test.ts @@ -26,25 +26,22 @@ import { stark, types, } from '../src'; -import { - TEST_TX_VERSION, - compiledC1Account, - compiledC1AccountCasm, - compiledC1v2, - compiledC1v2Casm, - compiledC210, - compiledC210Casm, - compiledComplexSierra, - compiledHelloSierra, - getTestAccount, - getTestProvider, -} from './config/fixtures'; +import { TEST_TX_VERSION, contracts, getTestAccount, getTestProvider } from './config/fixtures'; import { initializeMatcher } from './config/schema'; const { uint256, tuple, isCairo1Abi } = cairo; const { toHex } = num; const { starknetKeccak } = selector; +const compiledComplexSierra = contracts.ComplexSierra; +const compiledC1Account = contracts.C1Account.sierra; +const compiledC1AccountCasm = contracts.C1Account.casm; +const compiledC1v2 = contracts.C1v2.sierra; +const compiledC1v2Casm = contracts.C1v2.casm; +const compiledC210 = contracts.C210.sierra; +const compiledC210Casm = contracts.C210.casm; +const compiledHelloSierra = contracts.HelloSierra.sierra; + describe('Cairo 1', () => { const provider = getTestProvider(); const account = getTestAccount(provider); diff --git a/__tests__/cairo1v2_typed.test.ts b/__tests__/cairo1v2_typed.test.ts index a45bbd34e..051333db9 100644 --- a/__tests__/cairo1v2_typed.test.ts +++ b/__tests__/cairo1v2_typed.test.ts @@ -29,26 +29,23 @@ import { import { hexToDecimalString } from '../src/utils/num'; import { encodeShortString } from '../src/utils/shortString'; import { isString } from '../src/utils/typed'; -import { - TEST_TX_VERSION, - compiledC1Account, - compiledC1AccountCasm, - compiledC1v2, - compiledC1v2Casm, - compiledC210, - compiledC210Casm, - compiledC240, - compiledC240Casm, - compiledComplexSierra, - getTestAccount, - getTestProvider, -} from './config/fixtures'; +import { TEST_TX_VERSION, contracts, getTestAccount, getTestProvider } from './config/fixtures'; import { initializeMatcher } from './config/schema'; const { uint256, tuple, isCairo1Abi } = cairo; const { toHex } = num; const { starknetKeccak } = selector; +const compiledComplexSierra = contracts.ComplexSierra; +const compiledC1Account = contracts.C1Account.sierra; +const compiledC1AccountCasm = contracts.C1Account.casm; +const compiledC1v2 = contracts.C1v2.sierra; +const compiledC1v2Casm = contracts.C1v2.casm; +const compiledC210 = contracts.C210.sierra; +const compiledC210Casm = contracts.C210.casm; +const compiledC240 = contracts.C240.sierra; +const compiledC240Casm = contracts.C240.casm; + describe('Cairo 1', () => { const provider = getTestProvider(); const account = getTestAccount(provider); diff --git a/__tests__/cairov24onward.test.ts b/__tests__/cairov24onward.test.ts index 86de024f3..7df3b283d 100644 --- a/__tests__/cairov24onward.test.ts +++ b/__tests__/cairov24onward.test.ts @@ -16,20 +16,18 @@ import { } from '../src'; import { hexToDecimalString } from '../src/utils/num'; import { encodeShortString } from '../src/utils/shortString'; -import { - compiledC240, - compiledC240Casm, - compiledC260, - compiledC260Casm, - compiledNonZero, - compiledNonZeroCasm, - compiledTuple, - compiledTupleCasm, - compiledU512, - compiledU512Casm, - getTestAccount, - getTestProvider, -} from './config/fixtures'; +import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; + +const compiledC240 = contracts.C240.sierra; +const compiledC240Casm = contracts.C240.casm; +const compiledC260 = contracts.C260.sierra; +const compiledC260Casm = contracts.C260.casm; +const compiledNonZero = contracts.NonZero.sierra; +const compiledNonZeroCasm = contracts.NonZero.casm; +const compiledTuple = contracts.Tuple.sierra; +const compiledTupleCasm = contracts.Tuple.casm; +const compiledU512 = contracts.U512.sierra; +const compiledU512Casm = contracts.U512.casm; describe('Cairo v2.4 onwards', () => { const provider = getTestProvider(); diff --git a/__tests__/config/fixtures.ts b/__tests__/config/fixtures.ts index 80cd73c25..73bb0253e 100644 --- a/__tests__/config/fixtures.ts +++ b/__tests__/config/fixtures.ts @@ -11,81 +11,72 @@ import { import { ETransactionVersion } from '../../src/types/api'; import { toHex } from '../../src/utils/num'; import { wait } from '../../src/utils/provider'; +import { isString } from '../../src/utils/typed'; -const readContract = (name: string): LegacyCompiledContract => - json.parse( - fs.readFileSync(path.resolve(__dirname, `../../__mocks__/${name}.json`)).toString('ascii') - ); +const readFile = (subpath: string) => fs.readFileSync(path.resolve(__dirname, subpath)); -const readContractSierraCasm = (name: string): CompiledSierraCasm => - json.parse( - fs.readFileSync(path.resolve(__dirname, `../../__mocks__/${name}.casm`)).toString('ascii') - ); +const readContract = (name: string, extension: string = 'json'): T => + json.parse(readFile(`../../__mocks__/${name}.${extension}`).toString('ascii')); -const readContractSierra = (name: string): CompiledSierra => - json.parse( - fs.readFileSync(path.resolve(__dirname, `../../__mocks__/${name}.json`)).toString('ascii') - ); +const readContractSierra = readContract; +const readContractSierraCasm = (name: string) => readContract(name, 'casm'); -export const compiledOpenZeppelinAccount = readContract('Account'); -export const compiledErc20 = readContract('ERC20'); -export const compiledErc20Echo = readContract('ERC20-echo'); -export const compiledErc20OZ = readContractSierra('cairo/ERC20-241/ERC20OZ081.sierra'); -export const compiledErc20OZCasm = readContractSierraCasm('cairo/ERC20-241/ERC20OZ081'); -export const compiledL1L2 = readContract('l1l2_compiled'); -export const compiledTypeTransformation = readContract('contract'); -export const compiledMulticall = readContract('multicall'); -export const compiledTestDapp = readContract('TestDapp'); -export const compiledHashSierra = readContractSierra('cairo/hash/hash'); -export const compiledHashSierraCasm = readContractSierraCasm('cairo/hash/hash'); -export const compiledHelloSierra = readContractSierra('cairo/helloSierra/hello'); -export const compiledHelloSierraCasm = readContractSierraCasm('cairo/helloSierra/hello'); -export const compiledComplexSierra = readContractSierra('cairo/complexInput/complexInput'); -export const compiledC1Account = readContractSierra('cairo/account/accountOZ080'); -export const compiledC1AccountCasm = readContractSierraCasm('cairo/account/accountOZ080'); -export const compiledArgentX4Account = readContractSierra('cairo/account/accountArgent040'); -export const compiledArgentX4AccountCasm = readContractSierraCasm('cairo/account/accountArgent040'); -export const compiledC1v2 = readContractSierra('cairo/helloCairo2/compiled'); -export const compiledC1v2Casm = readContractSierraCasm('cairo/helloCairo2/compiled'); -export const compiledC210 = readContractSierra('cairo/cairo210/cairo210.sierra'); -export const compiledC210Casm = readContractSierraCasm('cairo/cairo210/cairo210'); -export const compiledC240 = readContractSierra('cairo/cairo240/string.sierra'); -export const compiledC240Casm = readContractSierraCasm('cairo/cairo240/string'); -export const compiledEthAccount = readContractSierra( - 'cairo/ethSigner/openzeppelin_EthAccount090.sierra' -); -export const compiledEthCasm = readContractSierraCasm('cairo/ethSigner/openzeppelin_EthAccount090'); -export const compiledDummy1Eth = readContractSierra('cairo/ethSigner/dummy1ForEth.sierra'); -export const compiledDummy1EthCasm = readContractSierraCasm('cairo/ethSigner/dummy1ForEth'); -export const compiledDummy2Eth = readContractSierra('cairo/ethSigner/dummy2ForEth.sierra'); -export const compiledDummy2EthCasm = readContractSierraCasm('cairo/ethSigner/dummy2ForEth'); -export const compiledEthPubk = readContractSierra('cairo/ethSigner/testEthPubKey.sierra'); -export const compiledEthPubkCasm = readContractSierraCasm('cairo/ethSigner/testEthPubKey'); -export const compiledC260 = readContractSierra('cairo/cairo260/hello260.sierra'); -export const compiledC260Casm = readContractSierraCasm('cairo/cairo260/hello260'); -export const compiledTuple = readContractSierra('cairo/cairo253/tupleResponse.sierra'); -export const compiledTupleCasm = readContractSierraCasm('cairo/cairo253/tupleResponse'); -export const compiledU512 = readContractSierra('cairo/cairo260/u512.sierra'); -export const compiledU512Casm = readContractSierraCasm('cairo/cairo260/u512'); -// StarknetId -export const compiledStarknetId = readContractSierra('starknetId/identity/identity.sierra'); -export const compiledStarknetIdCasm = readContractSierraCasm('starknetId/identity/identity'); -export const compiledNaming = readContractSierra('starknetId/naming/naming.sierra'); -export const compiledNamingCasm = readContractSierraCasm('starknetId/naming/naming'); -export const compiledPricing = readContractSierra('starknetId/pricing/pricing.sierra'); -export const compiledPricingCasm = readContractSierraCasm('starknetId/pricing/pricing'); -export const compiledTestRejectSierra = readContractSierra('cairo/testReject/test_reject.sierra'); -export const compiledTestRejectCasm = readContractSierraCasm('cairo/testReject/test_reject'); -export const compiledSidMulticall = readContractSierra('starknetId/multicall/multicall.sierra'); -export const compiledSidMulticallCasm = readContractSierraCasm('starknetId/multicall/multicall'); -export const compiledNonZero = readContractSierra('cairo/cairo263/zeroable.sierra'); -export const compiledNonZeroCasm = readContractSierraCasm('cairo/cairo263/zeroable'); -export const compiledOnlyConstructorSierra = readContractSierra( - 'cairo/onlyConstructor/onlyConstructor.sierra' -); -export const compiledOnlyConstructorCasm = readContractSierraCasm( - 'cairo/onlyConstructor/onlyConstructor' -); +const readContractSet = (name: string, pathPrefix: string = 'cairo') => ({ + sierra: readContractSierra(`${pathPrefix}/${name}.sierra`), + casm: readContractSierraCasm(`${pathPrefix}/${name}`), +}); + +const mapContractSets = >( + contractRecord: T, + pathPrefix?: string +): { [K in keyof T]: T[K] extends string ? ReturnType : T[K] } => + Object.fromEntries( + Object.entries(contractRecord).map(([key, value]) => [ + key, + isString(value) ? readContractSet(value, pathPrefix) : value, + ]) + ) as any; + +// cairo/ contracts are retrieved as a { sierra, casm } set +const compiledContracts = { + OpenZeppelinAccount: readContract('Account'), + Erc20: readContract('ERC20'), + Erc20Echo: readContract('ERC20-echo'), + L1L2: readContract('l1l2_compiled'), + TypeTransformation: readContract('contract'), + Multicall: readContract('multicall'), + TestDapp: readContract('TestDapp'), + ComplexSierra: readContractSierra('cairo/complexInput/complexInput'), + // cairo/ + Erc20OZ: 'ERC20-241/ERC20OZ081', + HashSierra: 'hash/hash', + HelloSierra: 'helloSierra/hello', + C1v2: 'helloCairo2/compiled', + C210: 'cairo210/cairo210', + C240: 'cairo240/string', + Tuple: 'cairo253/tupleResponse', + C260: 'cairo260/hello260', + U512: 'cairo260/u512', + NonZero: 'cairo263/zeroable', + OnlyConstructor: 'onlyConstructor/onlyConstructor', + C1Account: 'account/accountOZ080', + ArgentX4Account: 'account/accountArgent040', + EthAccount: 'ethSigner/openzeppelin_EthAccount090', + Dummy1Eth: 'ethSigner/dummy1ForEth', + Dummy2Eth: 'ethSigner/dummy2ForEth', + EthPubk: 'ethSigner/testEthPubKey', + TestReject: 'testReject/test_reject', + starknetId: mapContractSets( + { + StarknetId: 'identity/identity', + Naming: 'naming/naming', + Pricing: 'pricing/pricing', + SidMulticall: 'multicall/multicall', + }, + 'starknetId' + ), +}; +export const contracts = mapContractSets(compiledContracts); export function getTestProvider( isProvider?: true, diff --git a/__tests__/contract.test.ts b/__tests__/contract.test.ts index d72db6f22..848769433 100644 --- a/__tests__/contract.test.ts +++ b/__tests__/contract.test.ts @@ -15,17 +15,14 @@ import { getSelectorFromName } from '../src/utils/hash'; import { hexToDecimalString, toBigInt } from '../src/utils/num'; import { encodeShortString } from '../src/utils/shortString'; import { uint256ToBN } from '../src/utils/uint256'; -import { - compiledErc20, - compiledErc20Echo, - compiledMulticall, - compiledTypeTransformation, - describeIfDevnet, - getTestAccount, - getTestProvider, -} from './config/fixtures'; +import { contracts, describeIfDevnet, getTestAccount, getTestProvider } from './config/fixtures'; import { initializeMatcher } from './config/schema'; +const compiledErc20 = contracts.Erc20; +const compiledErc20Echo = contracts.Erc20Echo; +const compiledTypeTransformation = contracts.TypeTransformation; +const compiledMulticall = contracts.Multicall; + describe('contract module', () => { let erc20Address: string; const provider = getTestProvider(); diff --git a/__tests__/defaultProvider.test.ts b/__tests__/defaultProvider.test.ts index 232ab7c27..25fad9696 100644 --- a/__tests__/defaultProvider.test.ts +++ b/__tests__/defaultProvider.test.ts @@ -10,7 +10,7 @@ import { import { toBigInt } from '../src/utils/num'; import { encodeShortString } from '../src/utils/shortString'; import { - compiledErc20, + contracts, erc20ClassHash, getTestAccount, getTestProvider, @@ -18,6 +18,8 @@ import { } from './config/fixtures'; import { initializeMatcher } from './config/schema'; +const compiledErc20 = contracts.Erc20; + const { isPendingStateUpdate } = provider; const testProvider = new Provider(getTestProvider()); diff --git a/__tests__/rpcProvider.test.ts b/__tests__/rpcProvider.test.ts index af039910a..428c02cdd 100644 --- a/__tests__/rpcProvider.test.ts +++ b/__tests__/rpcProvider.test.ts @@ -20,11 +20,7 @@ import { StarknetChainId } from '../src/constants'; import { felt, uint256 } from '../src/utils/calldata/cairo'; import { toBigInt, toHexString } from '../src/utils/num'; import { - compiledC1v2, - compiledC1v2Casm, - compiledErc20Echo, - compiledL1L2, - compiledOpenZeppelinAccount, + contracts, createBlockForDevnet, describeIfDevnet, describeIfNotDevnet, @@ -37,6 +33,12 @@ import { } from './config/fixtures'; import { initializeMatcher } from './config/schema'; +const compiledErc20Echo = contracts.Erc20Echo; +const compiledL1L2 = contracts.L1L2; +const compiledOpenZeppelinAccount = contracts.OpenZeppelinAccount; +const compiledC1v2 = contracts.C1v2.sierra; +const compiledC1v2Casm = contracts.C1v2.casm; + describeIfRpc('RPCProvider', () => { const rpcProvider = getTestProvider(false); const provider = getTestProvider(); diff --git a/__tests__/transactionReceipt.test.ts b/__tests__/transactionReceipt.test.ts index 98572cfc1..a26ff5c77 100644 --- a/__tests__/transactionReceipt.test.ts +++ b/__tests__/transactionReceipt.test.ts @@ -6,12 +6,10 @@ import { SuccessfulTransactionReceiptResponse, TransactionExecutionStatus, } from '../src'; -import { - compiledTestRejectCasm, - compiledTestRejectSierra, - getTestAccount, - getTestProvider, -} from './config/fixtures'; +import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; + +const compiledTestRejectSierra = contracts.TestReject.sierra; +const compiledTestRejectCasm = contracts.TestReject.casm; describe('Transaction receipt utility', () => { const provider = getTestProvider(); diff --git a/__tests__/utils/classHash.test.ts b/__tests__/utils/classHash.test.ts index 5ee66aa09..3232f5563 100644 --- a/__tests__/utils/classHash.test.ts +++ b/__tests__/utils/classHash.test.ts @@ -1,13 +1,12 @@ import { hash } from '../../src'; -import { - compiledC260Casm, - compiledErc20, - compiledHashSierra, - compiledHashSierraCasm, - compiledOpenZeppelinAccount, - compiledTestDapp, - erc20ClassHash, -} from '../config/fixtures'; +import { contracts, erc20ClassHash } from '../config/fixtures'; + +const compiledErc20 = contracts.Erc20; +const compiledOpenZeppelinAccount = contracts.OpenZeppelinAccount; +const compiledTestDapp = contracts.TestDapp; +const compiledC260Casm = contracts.C260.casm; +const compiledHashSierra = contracts.HashSierra.sierra; +const compiledHashSierraCasm = contracts.HashSierra.casm; describe('Hash Tester', () => { test('Test getSelectorFromName', () => { diff --git a/__tests__/utils/contract.test.ts b/__tests__/utils/contract.test.ts index d74529b49..11bcd2d9f 100644 --- a/__tests__/utils/contract.test.ts +++ b/__tests__/utils/contract.test.ts @@ -1,5 +1,9 @@ import { isSierra, extractContractHashes } from '../../src/utils/contract'; -import { compiledHelloSierra, compiledHelloSierraCasm, compiledErc20 } from '../config/fixtures'; +import { contracts } from '../config/fixtures'; + +const compiledErc20 = contracts.Erc20; +const compiledHelloSierra = contracts.HelloSierra.sierra; +const compiledHelloSierraCasm = contracts.HelloSierra.casm; describe('isSierra', () => { test('should return true for a contract in Sierra format', () => { diff --git a/__tests__/utils/ethSigner.test.ts b/__tests__/utils/ethSigner.test.ts index 53c0370ce..5ba3ab608 100644 --- a/__tests__/utils/ethSigner.test.ts +++ b/__tests__/utils/ethSigner.test.ts @@ -19,21 +19,23 @@ import { import { validateAndParseEthAddress } from '../../src/utils/eth'; import { ETransactionVersion } from '../../src/types/api'; import { - compiledDummy1Eth, - compiledDummy1EthCasm, - compiledDummy2Eth, - compiledDummy2EthCasm, - compiledErc20, - compiledEthAccount, - compiledEthCasm, - compiledEthPubk, - compiledEthPubkCasm, + contracts, describeIfDevnet, devnetETHtokenAddress, getTestAccount, getTestProvider, } from '../config/fixtures'; +const compiledErc20 = contracts.Erc20; +const compiledDummy1Eth = contracts.Dummy1Eth.sierra; +const compiledDummy1EthCasm = contracts.Dummy1Eth.casm; +const compiledDummy2Eth = contracts.Dummy2Eth.sierra; +const compiledDummy2EthCasm = contracts.Dummy2Eth.casm; +const compiledEthAccount = contracts.EthAccount.sierra; +const compiledEthCasm = contracts.EthAccount.casm; +const compiledEthPubk = contracts.EthPubk.sierra; +const compiledEthPubkCasm = contracts.EthPubk.casm; + describe('Ethereum signer', () => { describe('signer', () => { test('Generates random PK', () => { diff --git a/__tests__/utils/secp256k1Point.test.ts b/__tests__/utils/secp256k1Point.test.ts index 46b47571a..84ae134aa 100644 --- a/__tests__/utils/secp256k1Point.test.ts +++ b/__tests__/utils/secp256k1Point.test.ts @@ -1,7 +1,10 @@ /* eslint-disable no-new */ import { CallData } from '../../src/utils/calldata'; import { bigNumberishArrayToDecimalStringArray, toHex } from '../../src/utils/num'; -import { compiledEthAccount, compiledEthPubk } from '../config/fixtures'; +import { contracts } from '../config/fixtures'; + +const compiledEthAccount = contracts.EthAccount.sierra; +const compiledEthPubk = contracts.EthPubk.sierra; describe('secp256k1Point cairo type test', () => { const myCallDataAccount = new CallData(compiledEthAccount.abi); diff --git a/__tests__/utils/stark.browser.test.ts b/__tests__/utils/stark.browser.test.ts index ca0cf2d9b..14732ed2c 100644 --- a/__tests__/utils/stark.browser.test.ts +++ b/__tests__/utils/stark.browser.test.ts @@ -26,8 +26,8 @@ describe('compressProgram()', () => { const { stark } = require('../../src'); // eslint-disable-line global-require // eslint-disable-next-line global-require - const fixtures = require('../config/fixtures'); - const compiledAccount = fixtures.compiledOpenZeppelinAccount; + const { contracts } = require('../config/fixtures'); + const compiledAccount = contracts.OpenZeppelinAccount; test('compresses a contract program', () => { const compressed = stark.compressProgram(compiledAccount.program); diff --git a/__tests__/utils/stark.test.ts b/__tests__/utils/stark.test.ts index 04a82d456..6aeeb2879 100644 --- a/__tests__/utils/stark.test.ts +++ b/__tests__/utils/stark.test.ts @@ -2,9 +2,9 @@ import { CallData, RawArgs, UniversalDetails, json, stark } from '../../src'; import { EDataAvailabilityMode } from '../../src/types/api'; import { FeeEstimate } from '../../src/types/provider'; import { toBigInt, toHex } from '../../src/utils/num'; -import { compiledOpenZeppelinAccount } from '../config/fixtures'; +import { contracts } from '../config/fixtures'; -const compiledAccount = compiledOpenZeppelinAccount; +const compiledAccount = contracts.OpenZeppelinAccount; describe('stark', () => { describe('compressProgram()', () => { From 55e28bce26a58468dcd7571409e9bcd8a9c0bae8 Mon Sep 17 00:00:00 2001 From: Petar Penovic Date: Thu, 3 Oct 2024 23:32:17 +0200 Subject: [PATCH 3/3] test: inline compiled contract variables --- __tests__/account.outsideExecution.test.ts | 9 +-- __tests__/account.starknetId.test.ts | 25 +++----- __tests__/account.test.ts | 62 +++++++++----------- __tests__/cairo1.test.ts | 38 ++++++------- __tests__/cairo1v2.test.ts | 47 +++++++-------- __tests__/cairo1v2_typed.test.ts | 66 ++++++++++------------ __tests__/cairov24onward.test.ts | 45 +++++++-------- __tests__/contract.test.ts | 49 +++++++++------- __tests__/defaultProvider.test.ts | 4 +- __tests__/rpcProvider.test.ts | 18 ++---- __tests__/transactionReceipt.test.ts | 9 +-- __tests__/utils/classHash.test.ts | 21 +++---- __tests__/utils/contract.test.ts | 12 ++-- __tests__/utils/ethSigner.test.ts | 44 +++++++-------- __tests__/utils/secp256k1Point.test.ts | 7 +-- __tests__/utils/stark.test.ts | 10 ++-- 16 files changed, 203 insertions(+), 263 deletions(-) diff --git a/__tests__/account.outsideExecution.test.ts b/__tests__/account.outsideExecution.test.ts index 15010a53f..d24c95c32 100644 --- a/__tests__/account.outsideExecution.test.ts +++ b/__tests__/account.outsideExecution.test.ts @@ -25,9 +25,6 @@ import { getSelectorFromName } from '../src/utils/hash'; import { getDecimalString } from '../src/utils/num'; import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; -const compiledErc20OZ = contracts.Erc20OZ.sierra; -const compiledArgentX4Account = contracts.ArgentX4Account.sierra; - describe('Account and OutsideExecution', () => { const ethAddress = '0x49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7'; const provider = new Provider(getTestProvider()); @@ -37,11 +34,11 @@ describe('Account and OutsideExecution', () => { const targetPubK = ec.starkCurve.getStarkKey(targetPK); // For ERC20 transfer outside call const recipientAccount = executorAccount; - const ethContract = new Contract(compiledErc20OZ.abi, ethAddress, provider); + const ethContract = new Contract(contracts.Erc20OZ.sierra.abi, ethAddress, provider); beforeAll(async () => { // Deploy the SNIP-9 signer account (ArgentX v 0.4.0, using SNIP-9 v2): - const calldataAX = new CallData(compiledArgentX4Account.abi); + const calldataAX = new CallData(contracts.ArgentX4Account.sierra.abi); const axSigner = new CairoCustomEnum({ Starknet: { pubkey: targetPubK } }); const axGuardian = new CairoOption(CairoOptionVariant.None); const constructorAXCallData = calldataAX.compile('constructor', { @@ -49,7 +46,7 @@ describe('Account and OutsideExecution', () => { guardian: axGuardian, }); const response = await executorAccount.declareAndDeploy({ - contract: compiledArgentX4Account, + contract: contracts.ArgentX4Account.sierra, classHash: '0x36078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f', compiledClassHash: '0x7a663375245780bd307f56fde688e33e5c260ab02b76741a57711c5b60d47f6', constructorCalldata: constructorAXCallData, diff --git a/__tests__/account.starknetId.test.ts b/__tests__/account.starknetId.test.ts index b7acc3bcb..17edd5da6 100644 --- a/__tests__/account.starknetId.test.ts +++ b/__tests__/account.starknetId.test.ts @@ -3,15 +3,6 @@ import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; const { hexToDecimalString } = num; -const compiledNaming = contracts.starknetId.Naming.sierra; -const compiledNamingCasm = contracts.starknetId.Naming.casm; -const compiledPricing = contracts.starknetId.Pricing.sierra; -const compiledPricingCasm = contracts.starknetId.Pricing.casm; -const compiledSidMulticall = contracts.starknetId.SidMulticall.sierra; -const compiledSidMulticallCasm = contracts.starknetId.SidMulticall.casm; -const compiledStarknetId = contracts.starknetId.StarknetId.sierra; -const compiledStarknetIdCasm = contracts.starknetId.StarknetId.casm; - describe('deploy and test Wallet', () => { const provider = new Provider(getTestProvider()); const account = getTestAccount(provider); @@ -23,32 +14,32 @@ describe('deploy and test Wallet', () => { beforeAll(async () => { // Deploy Starknet id contract const idResponse = await account.declareAndDeploy({ - contract: compiledStarknetId, - casm: compiledStarknetIdCasm, + contract: contracts.starknetId.StarknetId.sierra, + casm: contracts.starknetId.StarknetId.casm, constructorCalldata: [account.address, 0], }); identityAddress = idResponse.deploy.contract_address; // Deploy pricing contract const pricingResponse = await account.declareAndDeploy({ - contract: compiledPricing, - casm: compiledPricingCasm, + contract: contracts.starknetId.Pricing.sierra, + casm: contracts.starknetId.Pricing.casm, constructorCalldata: [devnetERC20Address], }); const pricingAddress = pricingResponse.deploy.contract_address; // Deploy naming contract const namingResponse = await account.declareAndDeploy({ - contract: compiledNaming, - casm: compiledNamingCasm, + contract: contracts.starknetId.Naming.sierra, + casm: contracts.starknetId.Naming.casm, constructorCalldata: [identityAddress, pricingAddress, 0, account.address], }); namingAddress = namingResponse.deploy.contract_address; // Deploy multicall contract const multicallResponse = await account.declareAndDeploy({ - contract: compiledSidMulticall, - casm: compiledSidMulticallCasm, + contract: contracts.starknetId.SidMulticall.sierra, + casm: contracts.starknetId.SidMulticall.casm, }); multicallAddress = multicallResponse.deploy.contract_address; diff --git a/__tests__/account.test.ts b/__tests__/account.test.ts index 20a0369e8..fc1916225 100644 --- a/__tests__/account.test.ts +++ b/__tests__/account.test.ts @@ -34,12 +34,6 @@ const { randomAddress } = stark; const { uint256 } = cairo; const { Signature } = ec.starkCurve; -const compiledErc20 = contracts.Erc20; -const compiledOpenZeppelinAccount = contracts.OpenZeppelinAccount; -const compiledTestDapp = contracts.TestDapp; -const compiledHelloSierra = contracts.HelloSierra.sierra; -const compiledHelloSierraCasm = contracts.HelloSierra.casm; - describe('deploy and test Wallet', () => { const provider = new Provider(getTestProvider()); const account = getTestAccount(provider); @@ -53,7 +47,7 @@ describe('deploy and test Wallet', () => { expect(account).toBeInstanceOf(Account); dd = await account.declareAndDeploy({ - contract: compiledErc20, + contract: contracts.Erc20, constructorCalldata: [ encodeShortString('Token'), encodeShortString('ERC20'), @@ -62,17 +56,17 @@ describe('deploy and test Wallet', () => { }); erc20Address = dd.deploy.contract_address; - erc20 = new Contract(compiledErc20.abi, erc20Address, provider); + erc20 = new Contract(contracts.Erc20.abi, erc20Address, provider); const { balance } = await erc20.balanceOf(account.address); expect(BigInt(balance.low).toString()).toStrictEqual(BigInt(1000).toString()); const dappResponse = await account.declareAndDeploy({ - contract: compiledTestDapp, + contract: contracts.TestDapp, classHash: '0x04367b26fbb92235e8d1137d19c080e6e650a6889ded726d00658411cc1046f5', }); - dapp = new Contract(compiledTestDapp.abi, dappResponse.deploy.contract_address!, provider); + dapp = new Contract(contracts.TestDapp.abi, dappResponse.deploy.contract_address!, provider); }); xtest('validate TS for redeclare - skip testing', async () => { @@ -123,7 +117,7 @@ describe('deploy and test Wallet', () => { // declare account const declareAccount = await account.declareIfNot({ - contract: compiledOpenZeppelinAccount, + contract: contracts.OpenZeppelinAccount, }); const accountClassHash = declareAccount.class_hash; @@ -252,7 +246,7 @@ describe('deploy and test Wallet', () => { const invocation = await provider.prepareInvocations([ { type: TransactionType.DECLARE, - contract: compiledErc20, + contract: contracts.Erc20, }, ]); if (invocation.length) { @@ -266,8 +260,8 @@ describe('deploy and test Wallet', () => { const invocation = await provider.prepareInvocations([ { type: TransactionType.DECLARE, - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }, ]); @@ -313,7 +307,7 @@ describe('deploy and test Wallet', () => { }); test('simulate DEPLOY_ACCOUNT - Cairo 0 Account', async () => { const declareAccount = await account.declareIfNot({ - contract: compiledOpenZeppelinAccount, + contract: contracts.OpenZeppelinAccount, }); const accountClassHash = declareAccount.class_hash; if (declareAccount.transaction_hash) { @@ -482,7 +476,7 @@ describe('deploy and test Wallet', () => { test('Declare ERC20 contract', async () => { const declareTx = await account.declareIfNot({ - contract: compiledErc20, + contract: contracts.Erc20, classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a', }); if (declareTx.transaction_hash) { @@ -495,7 +489,7 @@ describe('deploy and test Wallet', () => { describe('Declare and UDC Deploy Flow', () => { test('ERC20 Declare', async () => { const declareTx = await account.declareIfNot({ - contract: compiledErc20, + contract: contracts.Erc20, }); if (declareTx.transaction_hash) { @@ -587,7 +581,7 @@ describe('deploy and test Wallet', () => { beforeAll(async () => { const declareAccount = await account.declareIfNot({ - contract: compiledOpenZeppelinAccount, + contract: contracts.OpenZeppelinAccount, }); accountClassHash = declareAccount.class_hash; if (declareAccount.transaction_hash) { @@ -707,8 +701,8 @@ describe('deploy and test Wallet', () => { }); const hashes = extractContractHashes({ - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }); const isDeclaredCairo1 = await account.isClassDeclared({ classHash: hashes.classHash }); @@ -745,7 +739,7 @@ describe('deploy and test Wallet', () => { // Cairo 0 type: TransactionType.DECLARE, payload: { - contract: compiledErc20, + contract: contracts.Erc20, classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a', }, }, @@ -756,8 +750,8 @@ describe('deploy and test Wallet', () => { { // Cairo 1.1.0, if declared estimate error with can't redeclare same contract type: TransactionType.DECLARE, - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }, ] : []), @@ -800,15 +794,15 @@ describe('deploy and test Wallet', () => { // Cairo 0 type: TransactionType.DECLARE, payload: { - contract: compiledErc20, + contract: contracts.Erc20, classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a', }, }, { // Cairo 1.1.0, if declared estimate error with can't redeclare same contract type: TransactionType.DECLARE, - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }, ]); @@ -825,8 +819,8 @@ describe('deploy and test Wallet', () => { // TODO @dhruvkelawala check expectation for feeTransactionVersion // Cairo 1 contract const ddc1: DeclareDeployUDCResponse = await account.declareAndDeploy({ - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }); // const innerInvokeEstFeeSpy = jest.spyOn(account.signer, 'signTransaction'); @@ -851,21 +845,21 @@ describe('unit', () => { test('declareIfNot', async () => { const declare = await account.declareIfNot({ - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }); expect(declare).toMatchSchemaRef('DeclareContractResponse'); await expect( account.declare({ - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }) ).rejects.toThrow(); const redeclare = await account.declareIfNot({ - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }); expect(redeclare.class_hash).toBe(declare.class_hash); }); diff --git a/__tests__/cairo1.test.ts b/__tests__/cairo1.test.ts index ad2c4df6e..3d998fc2c 100644 --- a/__tests__/cairo1.test.ts +++ b/__tests__/cairo1.test.ts @@ -30,14 +30,6 @@ const { uint256, tuple, isCairo1Abi } = cairo; const { toHex } = num; const { starknetKeccak } = selector; -const compiledComplexSierra = contracts.ComplexSierra; -const compiledC1Account = contracts.C1Account.sierra; -const compiledC1AccountCasm = contracts.C1Account.casm; -const compiledHelloSierra = contracts.HelloSierra.sierra; -const compiledHelloSierraCasm = contracts.HelloSierra.casm; -const compiledOnlyConstructorSierra = contracts.OnlyConstructor.sierra; -const compiledOnlyConstructorCasm = contracts.OnlyConstructor.casm; - describeIfDevnet('Cairo 1 Devnet', () => { describe('API & Contract interactions', () => { const provider = getTestProvider(); @@ -49,20 +41,24 @@ describeIfDevnet('Cairo 1 Devnet', () => { beforeAll(async () => { dd = await account.declareAndDeploy({ - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }); - cairo1Contract = new Contract(compiledHelloSierra.abi, dd.deploy.contract_address, account); + cairo1Contract = new Contract( + contracts.HelloSierra.sierra.abi, + dd.deploy.contract_address, + account + ); const ddOnlyConstructor = await account.declareAndDeploy({ - contract: compiledOnlyConstructorSierra, - casm: compiledOnlyConstructorCasm, + contract: contracts.OnlyConstructor.sierra, + casm: contracts.OnlyConstructor.casm, constructorCalldata: [101, account.address], }); onlyConstructorContract = new Contract( - compiledOnlyConstructorSierra.abi, + contracts.OnlyConstructor.sierra.abi, ddOnlyConstructor.deploy.contract_address, account ); @@ -81,8 +77,8 @@ describeIfDevnet('Cairo 1 Devnet', () => { test('ContractFactory on Cairo1', async () => { const c1CFactory = new ContractFactory({ - compiledContract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + compiledContract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, account, }); const cfContract = await c1CFactory.deploy(); @@ -95,12 +91,12 @@ describeIfDevnet('Cairo 1 Devnet', () => { await account.declare({ contract: cc0 as CompiledSierra, - casm: compiledHelloSierraCasm, + casm: contracts.HelloSierra.casm, }); await account.declare({ contract: cc0_1 as CompiledSierra, - casm: compiledHelloSierraCasm, + casm: contracts.HelloSierra.casm, }); }); @@ -436,7 +432,7 @@ describeIfDevnet('Cairo 1 Devnet', () => { ], ]; - const contractCallData: CallData = new CallData(compiledComplexSierra.abi); + const contractCallData: CallData = new CallData(contracts.ComplexSierra.abi); const callDataFromObject: Calldata = contractCallData.compile('constructor', myRawArgsObject); const callDataFromArray: Calldata = contractCallData.compile('constructor', myRawArgsArray); const expectedResult = [ @@ -526,8 +522,8 @@ describeIfDevnet('Cairo 1 Devnet', () => { // declare account const declareAccount = await account.declareIfNot({ - contract: compiledC1Account, - casm: compiledC1AccountCasm, + contract: contracts.C1Account.sierra, + casm: contracts.C1Account.casm, }); if (declareAccount.transaction_hash) { await account.waitForTransaction(declareAccount.transaction_hash); diff --git a/__tests__/cairo1v2.test.ts b/__tests__/cairo1v2.test.ts index 0aa09fbe9..f8a1bda40 100644 --- a/__tests__/cairo1v2.test.ts +++ b/__tests__/cairo1v2.test.ts @@ -33,15 +33,6 @@ const { uint256, tuple, isCairo1Abi } = cairo; const { toHex } = num; const { starknetKeccak } = selector; -const compiledComplexSierra = contracts.ComplexSierra; -const compiledC1Account = contracts.C1Account.sierra; -const compiledC1AccountCasm = contracts.C1Account.casm; -const compiledC1v2 = contracts.C1v2.sierra; -const compiledC1v2Casm = contracts.C1v2.casm; -const compiledC210 = contracts.C210.sierra; -const compiledC210Casm = contracts.C210.casm; -const compiledHelloSierra = contracts.HelloSierra.sierra; - describe('Cairo 1', () => { const provider = getTestProvider(); const account = getTestAccount(provider); @@ -54,16 +45,20 @@ describe('Cairo 1', () => { beforeAll(async () => { dd = await account.declareAndDeploy({ - contract: compiledC1v2, - casm: compiledC1v2Casm, + contract: contracts.C1v2.sierra, + casm: contracts.C1v2.casm, }); - cairo1Contract = new Contract(compiledC1v2.abi, dd.deploy.contract_address, account); + cairo1Contract = new Contract(contracts.C1v2.sierra.abi, dd.deploy.contract_address, account); dd2 = await account.declareAndDeploy({ - contract: compiledC210, - casm: compiledC210Casm, + contract: contracts.C210.sierra, + casm: contracts.C210.casm, }); - cairo210Contract = new Contract(compiledC210.abi, dd2.deploy.contract_address, account); + cairo210Contract = new Contract( + contracts.C210.sierra.abi, + dd2.deploy.contract_address, + account + ); }); test('Declare & deploy v2 - Hello Cairo 1 contract', async () => { @@ -87,12 +82,12 @@ describe('Cairo 1', () => { await account.declare({ contract: cc0 as CompiledSierra, - casm: compiledC1v2Casm, + casm: contracts.C1v2.casm, }); await account.declare({ contract: cc0_1 as CompiledSierra, - casm: compiledC1v2Casm, + casm: contracts.C1v2.casm, }); }); @@ -225,7 +220,7 @@ describe('Cairo 1', () => { const result = await cairo1Contract.call('new_types', compiled.calldata as Calldata); expect(result).toStrictEqual({ '0': 123456789n, '1': 987654321n, '2': 657563474357n }); - const myCalldata = new CallData(compiledC1v2.abi); // test arrays + const myCalldata = new CallData(contracts.C1v2.sierra.abi); // test arrays const compiled2 = myCalldata.compile('array_new_types', { tup: cairo.tuple(256, '0x1234567890', '0xe3456'), tupa: cairo.tuple( @@ -601,7 +596,7 @@ describe('Cairo 1', () => { ], ]; - const contractCallData: CallData = new CallData(compiledComplexSierra.abi); + const contractCallData: CallData = new CallData(contracts.ComplexSierra.abi); const callDataFromObject: Calldata = contractCallData.compile('constructor', myRawArgsObject); const callDataFromArray: Calldata = contractCallData.compile('constructor', myRawArgsArray); const expectedResult = [ @@ -677,8 +672,8 @@ describe('Cairo 1', () => { }); test('myCallData.decodeParameters for Cairo 1', async () => { - const Cairo1HelloAbi = compiledHelloSierra; - const Cairo1Abi = compiledC1v2; + const Cairo1HelloAbi = contracts.HelloSierra.sierra; + const Cairo1Abi = contracts.C1v2.sierra; const helloCallData = new CallData(Cairo1HelloAbi.abi); const c1v2CallData = new CallData(Cairo1Abi.abi); @@ -766,8 +761,8 @@ describe('Cairo 1', () => { // declare account const declareAccount = await account.declareIfNot({ - contract: compiledC1Account, - casm: compiledC1AccountCasm, + contract: contracts.C1Account.sierra, + casm: contracts.C1Account.casm, }); if (declareAccount.transaction_hash) { await account.waitForTransaction(declareAccount.transaction_hash); @@ -839,11 +834,11 @@ describe('Cairo 1', () => { }; beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledC1v2, - casm: compiledC1v2Casm, + contract: contracts.C1v2.sierra, + casm: contracts.C1v2.casm, }); - eventContract = new Contract(compiledC1v2.abi, deploy.contract_address!, account); + eventContract = new Contract(contracts.C1v2.sierra.abi, deploy.contract_address!, account); }); test('parse event returning a regular struct', async () => { diff --git a/__tests__/cairo1v2_typed.test.ts b/__tests__/cairo1v2_typed.test.ts index 051333db9..d6a2777dc 100644 --- a/__tests__/cairo1v2_typed.test.ts +++ b/__tests__/cairo1v2_typed.test.ts @@ -36,16 +36,6 @@ const { uint256, tuple, isCairo1Abi } = cairo; const { toHex } = num; const { starknetKeccak } = selector; -const compiledComplexSierra = contracts.ComplexSierra; -const compiledC1Account = contracts.C1Account.sierra; -const compiledC1AccountCasm = contracts.C1Account.casm; -const compiledC1v2 = contracts.C1v2.sierra; -const compiledC1v2Casm = contracts.C1v2.casm; -const compiledC210 = contracts.C210.sierra; -const compiledC210Casm = contracts.C210.casm; -const compiledC240 = contracts.C240.sierra; -const compiledC240Casm = contracts.C240.casm; - describe('Cairo 1', () => { const provider = getTestProvider(); const account = getTestAccount(provider); @@ -58,19 +48,21 @@ describe('Cairo 1', () => { beforeAll(async () => { dd = await account.declareAndDeploy({ - contract: compiledC1v2, - casm: compiledC1v2Casm, + contract: contracts.C1v2.sierra, + casm: contracts.C1v2.casm, }); - cairo1Contract = new Contract(compiledC1v2.abi, dd.deploy.contract_address, account).typedv2( - tAbi - ); + cairo1Contract = new Contract( + contracts.C1v2.sierra.abi, + dd.deploy.contract_address, + account + ).typedv2(tAbi); dd2 = await account.declareAndDeploy({ - contract: compiledC210, - casm: compiledC210Casm, + contract: contracts.C210.sierra, + casm: contracts.C210.casm, }); cairo210Contract = new Contract( - compiledC210.abi, + contracts.C210.sierra.abi, dd2.deploy.contract_address, account ).typedv2(tAbi); @@ -97,12 +89,12 @@ describe('Cairo 1', () => { await account.declare({ contract: cc0 as CompiledSierra, - casm: compiledC1v2Casm, + casm: contracts.C1v2.casm, }); await account.declare({ contract: cc0_1 as CompiledSierra, - casm: compiledC1v2Casm, + casm: contracts.C1v2.casm, }); }); @@ -240,7 +232,7 @@ describe('Cairo 1', () => { const result = await cairo1Contract.call('new_types', compiled.calldata as Calldata); expect(result).toStrictEqual({ '0': 123456789n, '1': 987654321n, '2': 657563474357n }); - const myCalldata = new CallData(compiledC1v2.abi); // test arrays + const myCalldata = new CallData(contracts.C1v2.sierra.abi); // test arrays const compiled2 = myCalldata.compile('array_new_types', { tup: cairo.tuple(256, '0x1234567890', '0xe3456'), tupa: cairo.tuple( @@ -619,7 +611,7 @@ describe('Cairo 1', () => { ], ]; - const contractCallData: CallData = new CallData(compiledComplexSierra.abi); + const contractCallData: CallData = new CallData(contracts.ComplexSierra.abi); const callDataFromObject: Calldata = contractCallData.compile('constructor', myRawArgsObject); const callDataFromArray: Calldata = contractCallData.compile('constructor', myRawArgsArray); const expectedResult = [ @@ -707,8 +699,8 @@ describe('Cairo 1', () => { // declare account const declareAccount = await account.declareIfNot({ - contract: compiledC1Account, - casm: compiledC1AccountCasm, + contract: contracts.C1Account.sierra, + casm: contracts.C1Account.casm, }); if (declareAccount.transaction_hash) { await account.waitForTransaction(declareAccount.transaction_hash); @@ -780,13 +772,15 @@ describe('Cairo 1', () => { }; beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledC1v2, - casm: compiledC1v2Casm, + contract: contracts.C1v2.sierra, + casm: contracts.C1v2.casm, }); - eventContract = new Contract(compiledC1v2.abi, deploy.contract_address!, account).typedv2( - tAbi - ); + eventContract = new Contract( + contracts.C1v2.sierra.abi, + deploy.contract_address!, + account + ).typedv2(tAbi); }); test('parse event returning a regular struct', async () => { @@ -922,13 +916,15 @@ describe('Cairo 1', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledC240, - casm: compiledC240Casm, + contract: contracts.C240.sierra, + casm: contracts.C240.casm, }); - stringContract = new Contract(compiledC240.abi, deploy.contract_address, account).typedv2( - StringABI - ); + stringContract = new Contract( + contracts.C240.sierra.abi, + deploy.contract_address, + account + ).typedv2(StringABI); }); test('bytes31', async () => { @@ -941,7 +937,7 @@ describe('Cairo 1', () => { expect(callD1).toEqual([hexToDecimalString(encodeShortString(str))]); const callD2 = CallData.compile({ str }); expect(callD2).toEqual([hexToDecimalString(encodeShortString(str))]); - const myCallData = new CallData(compiledC240.abi); + const myCallData = new CallData(contracts.C240.sierra.abi); const myCalldata1 = myCallData.compile('proceed_bytes31', [str]); expect(myCalldata1).toEqual([encodeShortString(str)]); const myCalldata2 = myCallData.compile('proceed_bytes31', { str }); diff --git a/__tests__/cairov24onward.test.ts b/__tests__/cairov24onward.test.ts index 7df3b283d..9898109d8 100644 --- a/__tests__/cairov24onward.test.ts +++ b/__tests__/cairov24onward.test.ts @@ -18,17 +18,6 @@ import { hexToDecimalString } from '../src/utils/num'; import { encodeShortString } from '../src/utils/shortString'; import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; -const compiledC240 = contracts.C240.sierra; -const compiledC240Casm = contracts.C240.casm; -const compiledC260 = contracts.C260.sierra; -const compiledC260Casm = contracts.C260.casm; -const compiledNonZero = contracts.NonZero.sierra; -const compiledNonZeroCasm = contracts.NonZero.casm; -const compiledTuple = contracts.Tuple.sierra; -const compiledTupleCasm = contracts.Tuple.casm; -const compiledU512 = contracts.U512.sierra; -const compiledU512Casm = contracts.U512.casm; - describe('Cairo v2.4 onwards', () => { const provider = getTestProvider(); const account = getTestAccount(provider); @@ -38,11 +27,11 @@ describe('Cairo v2.4 onwards', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledC240, - casm: compiledC240Casm, + contract: contracts.C240.sierra, + casm: contracts.C240.casm, }); - stringContract = new Contract(compiledC240.abi, deploy.contract_address, account); + stringContract = new Contract(contracts.C240.sierra.abi, deploy.contract_address, account); }); test('bytes31', async () => { @@ -53,7 +42,7 @@ describe('Cairo v2.4 onwards', () => { expect(callD1).toEqual([hexToDecimalString(encodeShortString(str))]); const callD2 = CallData.compile({ str }); expect(callD2).toEqual([hexToDecimalString(encodeShortString(str))]); - const myCallData = new CallData(compiledC240.abi); + const myCallData = new CallData(contracts.C240.sierra.abi); const myCalldata1 = myCallData.compile('proceed_bytes31', [str]); expect(myCalldata1).toEqual([encodeShortString(str)]); const myCalldata2 = myCallData.compile('proceed_bytes31', { str }); @@ -106,11 +95,11 @@ describe('Cairo v2.4 onwards', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledTuple, - casm: compiledTupleCasm, + contract: contracts.Tuple.sierra, + casm: contracts.Tuple.casm, }); - tupleContract = new Contract(compiledTuple.abi, deploy.contract_address, account); + tupleContract = new Contract(contracts.Tuple.sierra.abi, deploy.contract_address, account); myCallData = new CallData(tupleContract.abi); }); @@ -222,8 +211,8 @@ describe('Cairo v2.4 onwards', () => { describe('Cairo2.6.0 Sierra1.5.0', () => { test('declare Sierra 1.5.0', async () => { const declare260Response = await account.declareIfNot({ - contract: compiledC260, - casm: compiledC260Casm, + contract: contracts.C260.sierra, + casm: contracts.C260.casm, }); expect(declare260Response.class_hash).toBe( '0x6184f1a71cad4bd123ff8bb3b97dc9ec876ced6489d9479cfdaada81a2f06d6' @@ -245,11 +234,11 @@ describe('Cairo v2.4 onwards', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledU512, - casm: compiledU512Casm, + contract: contracts.U512.sierra, + casm: contracts.U512.casm, }); - u512Contract = new Contract(compiledU512.abi, deploy.contract_address, account); + u512Contract = new Contract(contracts.U512.sierra.abi, deploy.contract_address, account); }); test('u512 compile', async () => { @@ -321,10 +310,14 @@ describe('Cairo v2.4 onwards', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledNonZero, - casm: compiledNonZeroCasm, + contract: contracts.NonZero.sierra, + casm: contracts.NonZero.casm, }); - nonZeroContract = new Contract(compiledNonZero.abi, deploy.contract_address, account); + nonZeroContract = new Contract( + contracts.NonZero.sierra.abi, + deploy.contract_address, + account + ); }); test('NonZero helpers', async () => { diff --git a/__tests__/contract.test.ts b/__tests__/contract.test.ts index 848769433..2ca4fb950 100644 --- a/__tests__/contract.test.ts +++ b/__tests__/contract.test.ts @@ -18,11 +18,6 @@ import { uint256ToBN } from '../src/utils/uint256'; import { contracts, describeIfDevnet, getTestAccount, getTestProvider } from './config/fixtures'; import { initializeMatcher } from './config/schema'; -const compiledErc20 = contracts.Erc20; -const compiledErc20Echo = contracts.Erc20Echo; -const compiledTypeTransformation = contracts.TypeTransformation; -const compiledMulticall = contracts.Multicall; - describe('contract module', () => { let erc20Address: string; const provider = getTestProvider(); @@ -39,19 +34,19 @@ describe('contract module', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledErc20, + contract: contracts.Erc20, classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a', constructorCalldata, }); - erc20Contract = new Contract(compiledErc20.abi, deploy.contract_address!, provider); + erc20Contract = new Contract(contracts.Erc20.abi, deploy.contract_address!, provider); const { deploy: multicallDeploy } = await account.declareAndDeploy({ - contract: compiledMulticall, + contract: contracts.Multicall, }); multicallContract = new Contract( - compiledMulticall.abi, + contracts.Multicall.abi, multicallDeploy.contract_address!, provider ); @@ -115,7 +110,7 @@ describe('contract module', () => { let factory: ContractFactory; beforeAll(async () => { factory = new ContractFactory({ - compiledContract: compiledErc20Echo, + compiledContract: contracts.Erc20Echo, classHash: factoryClassHash, account, }); @@ -158,11 +153,11 @@ describe('contract module', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledTypeTransformation, + contract: contracts.TypeTransformation, }); typeTransformedContract = new Contract( - compiledTypeTransformation.abi, + contracts.TypeTransformation.abi, deploy.contract_address!, provider ); @@ -266,17 +261,25 @@ describe('contract module', () => { describe('class ContractFactory {}', () => { beforeAll(async () => { await account.declareAndDeploy({ - contract: compiledErc20, + contract: contracts.Erc20, constructorCalldata, }); }); test('deployment of new contract', async () => { - const factory = new ContractFactory({ compiledContract: compiledErc20, classHash, account }); + const factory = new ContractFactory({ + compiledContract: contracts.Erc20, + classHash, + account, + }); const erc20 = await factory.deploy('Token', 'ERC20', wallet); expect(erc20).toBeInstanceOf(Contract); }); test('wait for deployment transaction', async () => { - const factory = new ContractFactory({ compiledContract: compiledErc20, classHash, account }); + const factory = new ContractFactory({ + compiledContract: contracts.Erc20, + classHash, + account, + }); const contract = await factory.deploy( CallData.compile({ name: encodeShortString('Token'), @@ -287,7 +290,11 @@ describe('contract module', () => { await expect(contract.deployed()).resolves.not.toThrow(); }); test('attach new contract', async () => { - const factory = new ContractFactory({ compiledContract: compiledErc20, classHash, account }); + const factory = new ContractFactory({ + compiledContract: contracts.Erc20, + classHash, + account, + }); const erc20 = factory.attach(erc20Address); expect(erc20).toBeInstanceOf(Contract); }); @@ -302,7 +309,7 @@ describe('Complex interaction', () => { let factory: ContractFactory; beforeAll(async () => { - factory = new ContractFactory({ compiledContract: compiledErc20Echo, classHash, account }); + factory = new ContractFactory({ compiledContract: contracts.Erc20Echo, classHash, account }); erc20Echo20Contract = await factory.deploy( 'Token', 'ERC20', @@ -322,7 +329,7 @@ describe('Complex interaction', () => { describeIfDevnet('speedup live tests', () => { test('declareDeploy with callData - all types using felt,uint256,tuple helpers', async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledErc20Echo, + contract: contracts.Erc20Echo, classHash, constructorCalldata: CallData.compile({ name: felt('Token'), @@ -335,7 +342,11 @@ describe('Complex interaction', () => { }), }); - erc20Echo20Contract = new Contract(compiledErc20Echo.abi, deploy.contract_address!, provider); + erc20Echo20Contract = new Contract( + contracts.Erc20Echo.abi, + deploy.contract_address!, + provider + ); expect(erc20Echo20Contract).toBeInstanceOf(Contract); }); diff --git a/__tests__/defaultProvider.test.ts b/__tests__/defaultProvider.test.ts index 25fad9696..2a3310936 100644 --- a/__tests__/defaultProvider.test.ts +++ b/__tests__/defaultProvider.test.ts @@ -18,8 +18,6 @@ import { } from './config/fixtures'; import { initializeMatcher } from './config/schema'; -const compiledErc20 = contracts.Erc20; - const { isPendingStateUpdate } = provider; const testProvider = new Provider(getTestProvider()); @@ -38,7 +36,7 @@ describe('defaultProvider', () => { expect(testProvider).toBeInstanceOf(Provider); const { deploy } = await account.declareAndDeploy({ - contract: compiledErc20, + contract: contracts.Erc20, constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet], }); diff --git a/__tests__/rpcProvider.test.ts b/__tests__/rpcProvider.test.ts index 428c02cdd..c2968e995 100644 --- a/__tests__/rpcProvider.test.ts +++ b/__tests__/rpcProvider.test.ts @@ -33,12 +33,6 @@ import { } from './config/fixtures'; import { initializeMatcher } from './config/schema'; -const compiledErc20Echo = contracts.Erc20Echo; -const compiledL1L2 = contracts.L1L2; -const compiledOpenZeppelinAccount = contracts.OpenZeppelinAccount; -const compiledC1v2 = contracts.C1v2.sierra; -const compiledC1v2Casm = contracts.C1v2.casm; - describeIfRpc('RPCProvider', () => { const rpcProvider = getTestProvider(false); const provider = getTestProvider(); @@ -141,7 +135,7 @@ describeIfRpc('RPCProvider', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledL1L2, + contract: contracts.L1L2, }); l1l2ContractCairo0Address = deploy.contract_address; }); @@ -169,8 +163,8 @@ describeIfRpc('RPCProvider', () => { beforeAll(async () => { const { deploy: deploy2 } = await account.declareAndDeploy({ - contract: compiledC1v2, - casm: compiledC1v2Casm, + contract: contracts.C1v2.sierra, + casm: contracts.C1v2.casm, }); l1l2ContractCairo1Address = deploy2.contract_address; await waitNextBlock(provider as RpcProvider, 5000); // in Sepolia Testnet, needs pending block validation before interacting @@ -323,7 +317,7 @@ describeIfRpc('RPCProvider', () => { ); const { deploy } = await account.declareAndDeploy({ - contract: compiledErc20Echo, + contract: contracts.Erc20Echo, classHash, constructorCalldata: CallData.compile({ name: felt('Token'), @@ -337,7 +331,7 @@ describeIfRpc('RPCProvider', () => { }); const erc20EchoContract = new Contract( - compiledErc20Echo.abi, + contracts.Erc20Echo.abi, deploy.contract_address!, account ); @@ -387,7 +381,7 @@ describeIfRpc('RPCProvider', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledOpenZeppelinAccount, + contract: contracts.OpenZeppelinAccount, constructorCalldata: [accountPublicKey], salt: accountPublicKey, }); diff --git a/__tests__/transactionReceipt.test.ts b/__tests__/transactionReceipt.test.ts index a26ff5c77..36159adbd 100644 --- a/__tests__/transactionReceipt.test.ts +++ b/__tests__/transactionReceipt.test.ts @@ -8,9 +8,6 @@ import { } from '../src'; import { contracts, getTestAccount, getTestProvider } from './config/fixtures'; -const compiledTestRejectSierra = contracts.TestReject.sierra; -const compiledTestRejectCasm = contracts.TestReject.casm; - describe('Transaction receipt utility', () => { const provider = getTestProvider(); const account = getTestAccount(provider); @@ -20,11 +17,11 @@ describe('Transaction receipt utility', () => { beforeAll(async () => { dd = await account.declareAndDeploy({ - contract: compiledTestRejectSierra, - casm: compiledTestRejectCasm, + contract: contracts.TestReject.sierra, + casm: contracts.TestReject.casm, }); await provider.waitForTransaction(dd.deploy.transaction_hash); - contract = new Contract(compiledTestRejectSierra.abi, dd.deploy.contract_address, account); + contract = new Contract(contracts.TestReject.sierra.abi, dd.deploy.contract_address, account); contract.connect(account); }); diff --git a/__tests__/utils/classHash.test.ts b/__tests__/utils/classHash.test.ts index 3232f5563..ea166799c 100644 --- a/__tests__/utils/classHash.test.ts +++ b/__tests__/utils/classHash.test.ts @@ -1,13 +1,6 @@ import { hash } from '../../src'; import { contracts, erc20ClassHash } from '../config/fixtures'; -const compiledErc20 = contracts.Erc20; -const compiledOpenZeppelinAccount = contracts.OpenZeppelinAccount; -const compiledTestDapp = contracts.TestDapp; -const compiledC260Casm = contracts.C260.casm; -const compiledHashSierra = contracts.HashSierra.sierra; -const compiledHashSierraCasm = contracts.HashSierra.casm; - describe('Hash Tester', () => { test('Test getSelectorFromName', () => { const hash0 = hash.getSelectorFromName('__validate__'); @@ -16,20 +9,20 @@ describe('Hash Tester', () => { describe('Compute ClassHash of various contracts Cairo0', () => { test('ERC20 Contract ClassHash', () => { - const classHash = hash.computeContractClassHash(compiledErc20); + const classHash = hash.computeContractClassHash(contracts.Erc20); expect(classHash).toEqual(erc20ClassHash); expect(classHash).toMatchInlineSnapshot( `"0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a"` ); - const hintedClassH = hash.computeHintedClassHash(compiledErc20); + const hintedClassH = hash.computeHintedClassHash(contracts.Erc20); expect(hintedClassH).toBe( '0x2819cbfc03fb25e1816c2aa6ec990062539a4470a8f57b78d27a6efbd8e1446' ); }); test('OZ ERC20 Contract ClassHash', () => { - const classHash = hash.computeContractClassHash(compiledOpenZeppelinAccount); + const classHash = hash.computeContractClassHash(contracts.OpenZeppelinAccount); expect(classHash).toMatchInlineSnapshot( `"0x36c7e49a16f8fc760a6fbdf71dde543d98be1fee2eda5daff59a0eeae066ed9"` @@ -37,7 +30,7 @@ describe('Hash Tester', () => { }); test('Test DApp Contract ClassHash', () => { - const classHash = hash.computeContractClassHash(compiledTestDapp); + const classHash = hash.computeContractClassHash(contracts.TestDapp); expect(classHash).toMatchInlineSnapshot( `"0x4367b26fbb92235e8d1137d19c080e6e650a6889ded726d00658411cc1046f5"` @@ -47,21 +40,21 @@ describe('Hash Tester', () => { describe('Compute CompiledClassHash & ClassHash Cairo1', () => { test('Hello - CompiledClassHash', () => { - const compiledClassHash = hash.computeCompiledClassHash(compiledHashSierraCasm); + const compiledClassHash = hash.computeCompiledClassHash(contracts.HashSierra.casm); expect(compiledClassHash).toEqual( '0x5c82c98f2ab111bd50293ba64bb18cf49037374783ad2486c712709c4ba0d89' ); }); test('Hello - CompiledClassHash Cairo2.6.0 Sierra1.5.0', () => { - const compiledClassHash = hash.computeCompiledClassHash(compiledC260Casm); + const compiledClassHash = hash.computeCompiledClassHash(contracts.C260.casm); expect(compiledClassHash).toEqual( '0x1725af24fbfa8050f4514651990b30e06bb9993e4e5c1051206f1bef218b1c6' ); }); test('Hello - ClassHash', () => { - const classHash = hash.computeSierraContractClassHash(compiledHashSierra); + const classHash = hash.computeSierraContractClassHash(contracts.HashSierra.sierra); expect(classHash).toEqual( '0x345df0a9b35ce05d03772ba7938acad66921c5c39c1a5af74aee72aa25c363e' ); diff --git a/__tests__/utils/contract.test.ts b/__tests__/utils/contract.test.ts index 11bcd2d9f..59e667be8 100644 --- a/__tests__/utils/contract.test.ts +++ b/__tests__/utils/contract.test.ts @@ -1,25 +1,21 @@ import { isSierra, extractContractHashes } from '../../src/utils/contract'; import { contracts } from '../config/fixtures'; -const compiledErc20 = contracts.Erc20; -const compiledHelloSierra = contracts.HelloSierra.sierra; -const compiledHelloSierraCasm = contracts.HelloSierra.casm; - describe('isSierra', () => { test('should return true for a contract in Sierra format', () => { - expect(isSierra(compiledHelloSierra)).toBe(true); + expect(isSierra(contracts.HelloSierra.sierra)).toBe(true); }); test('should return false for a contract not in Sierra format', () => { - expect(isSierra(compiledErc20)).toBe(false); + expect(isSierra(contracts.Erc20)).toBe(false); }); }); describe('extractContractHashes', () => { test('should properly extract hashes from contract', () => { const declareContractPayload = { - contract: compiledHelloSierra, - casm: compiledHelloSierraCasm, + contract: contracts.HelloSierra.sierra, + casm: contracts.HelloSierra.casm, }; const result = extractContractHashes(declareContractPayload); diff --git a/__tests__/utils/ethSigner.test.ts b/__tests__/utils/ethSigner.test.ts index 5ba3ab608..8a1e8e986 100644 --- a/__tests__/utils/ethSigner.test.ts +++ b/__tests__/utils/ethSigner.test.ts @@ -26,16 +26,6 @@ import { getTestProvider, } from '../config/fixtures'; -const compiledErc20 = contracts.Erc20; -const compiledDummy1Eth = contracts.Dummy1Eth.sierra; -const compiledDummy1EthCasm = contracts.Dummy1Eth.casm; -const compiledDummy2Eth = contracts.Dummy2Eth.sierra; -const compiledDummy2EthCasm = contracts.Dummy2Eth.casm; -const compiledEthAccount = contracts.EthAccount.sierra; -const compiledEthCasm = contracts.EthAccount.casm; -const compiledEthPubk = contracts.EthPubk.sierra; -const compiledEthPubkCasm = contracts.EthPubk.casm; - describe('Ethereum signer', () => { describe('signer', () => { test('Generates random PK', () => { @@ -78,11 +68,15 @@ describe('Ethereum signer', () => { beforeAll(async () => { const { deploy } = await account.declareAndDeploy({ - contract: compiledEthPubk, - casm: compiledEthPubkCasm, + contract: contracts.EthPubk.sierra, + casm: contracts.EthPubk.casm, }); - ethPubKContract = new Contract(compiledEthPubk.abi, deploy.contract_address, account); + ethPubKContract = new Contract( + contracts.EthPubk.sierra.abi, + deploy.contract_address, + account + ); }); test('secp256k1', async () => { @@ -107,8 +101,8 @@ describe('Ethereum signer', () => { let ethAccount: Account; beforeAll(async () => { const { transaction_hash: declTH, class_hash: decClassHash } = await account.declareIfNot({ - contract: compiledEthAccount, - casm: compiledEthCasm, + contract: contracts.EthAccount.sierra, + casm: contracts.EthAccount.casm, }); if (declTH) { await provider.waitForTransaction(declTH); @@ -120,7 +114,7 @@ describe('Ethereum signer', () => { addAddressPadding(encode.addHexPrefix(ethFullPublicKey.slice(4, -64))) ); const salt = pubKeyETHx.low; - const myCallData = new CallData(compiledEthAccount.abi); + const myCallData = new CallData(contracts.EthAccount.sierra.abi); const accountETHconstructorCalldata = myCallData.compile('constructor', { public_key: ethFullPublicKey, }); @@ -159,7 +153,7 @@ describe('Ethereum signer', () => { }); test('ETH account transaction V2', async () => { - const ethContract2 = new Contract(compiledErc20.abi, devnetETHtokenAddress, ethAccount); + const ethContract2 = new Contract(contracts.Erc20.abi, devnetETHtokenAddress, ethAccount); const respTransfer = await ethContract2.transfer( account.address, cairo.uint256(1 * 10 ** 4), @@ -174,8 +168,8 @@ describe('Ethereum signer', () => { }); test('ETH account declaration V2', async () => { - const accountTestSierra = compiledDummy1Eth; - const accountTestCasm = compiledDummy1EthCasm; + const accountTestSierra = contracts.Dummy1Eth.sierra; + const accountTestCasm = contracts.Dummy1Eth.casm; const { transaction_hash: declTH2, class_hash: decClassHash2 } = await ethAccount.declareIfNot( { contract: accountTestSierra, casm: accountTestCasm }, @@ -199,8 +193,8 @@ describe('Ethereum signer', () => { let ethAccount: Account; beforeAll(async () => { const { transaction_hash: declTH, class_hash: decClassHash } = await account.declareIfNot({ - contract: compiledEthAccount, - casm: compiledEthCasm, + contract: contracts.EthAccount.sierra, + casm: contracts.EthAccount.casm, }); if (declTH) { await provider.waitForTransaction(declTH); @@ -212,7 +206,7 @@ describe('Ethereum signer', () => { addAddressPadding(encode.addHexPrefix(ethFullPublicKey.slice(4, -64))) ); const salt = pubKeyETHx.low; - const myCallData = new CallData(compiledEthAccount.abi); + const myCallData = new CallData(contracts.EthAccount.sierra.abi); const accountETHconstructorCalldata = myCallData.compile('constructor', { public_key: ethFullPublicKey, }); @@ -269,7 +263,7 @@ describe('Ethereum signer', () => { }); test('ETH account transaction V3', async () => { - const strkContract2 = new Contract(compiledErc20.abi, devnetSTRKtokenAddress, ethAccount); + const strkContract2 = new Contract(contracts.Erc20.abi, devnetSTRKtokenAddress, ethAccount); const txCallData = strkContract2.populate('transfer', [ account.address, cairo.uint256(1 * 10 ** 4), @@ -294,8 +288,8 @@ describe('Ethereum signer', () => { }); test('ETH account declaration V3', async () => { - const accountTestSierra = compiledDummy2Eth; - const accountTestCasm = compiledDummy2EthCasm; + const accountTestSierra = contracts.Dummy2Eth.sierra; + const accountTestCasm = contracts.Dummy2Eth.casm; const payload: DeclareContractPayload = { contract: accountTestSierra, casm: accountTestCasm, diff --git a/__tests__/utils/secp256k1Point.test.ts b/__tests__/utils/secp256k1Point.test.ts index 84ae134aa..38a12852e 100644 --- a/__tests__/utils/secp256k1Point.test.ts +++ b/__tests__/utils/secp256k1Point.test.ts @@ -3,12 +3,9 @@ import { CallData } from '../../src/utils/calldata'; import { bigNumberishArrayToDecimalStringArray, toHex } from '../../src/utils/num'; import { contracts } from '../config/fixtures'; -const compiledEthAccount = contracts.EthAccount.sierra; -const compiledEthPubk = contracts.EthPubk.sierra; - describe('secp256k1Point cairo type test', () => { - const myCallDataAccount = new CallData(compiledEthAccount.abi); - const myCallDataTest = new CallData(compiledEthPubk.abi); + const myCallDataAccount = new CallData(contracts.EthAccount.sierra.abi); + const myCallDataTest = new CallData(contracts.EthPubk.sierra.abi); const ethPubKey = '0x8c7aea7d673a5858bdca128d124fb0765cceb2c16f198f4c14b328aa571331e6f6c87f51d5224d73d118765cb19d7565212f80be5048bff926ba791c17541c92'; test('secp256k1Point is an u512', () => { diff --git a/__tests__/utils/stark.test.ts b/__tests__/utils/stark.test.ts index 6aeeb2879..a44e8f28a 100644 --- a/__tests__/utils/stark.test.ts +++ b/__tests__/utils/stark.test.ts @@ -4,17 +4,15 @@ import { FeeEstimate } from '../../src/types/provider'; import { toBigInt, toHex } from '../../src/utils/num'; import { contracts } from '../config/fixtures'; -const compiledAccount = contracts.OpenZeppelinAccount; - describe('stark', () => { describe('compressProgram()', () => { test('compresses a contract program', () => { - const inputProgram = compiledAccount.program; + const inputProgram = contracts.OpenZeppelinAccount.program; const compressed = stark.compressProgram(inputProgram); expect(compressed).toMatchSnapshot(); }); test('works with strings', () => { - const inputProgram = json.stringify(compiledAccount.program); + const inputProgram = json.stringify(contracts.OpenZeppelinAccount.program); const compressed = stark.compressProgram(inputProgram); expect(compressed).toMatchSnapshot(); }); @@ -22,10 +20,10 @@ describe('stark', () => { describe('decompressProgram()', () => { test('decompress a contract program', () => { - const inputProgram = compiledAccount.program; + const inputProgram = contracts.OpenZeppelinAccount.program; const compressed = stark.compressProgram(inputProgram); const decompressed = stark.decompressProgram(compressed); - expect(decompressed).toMatchObject(compiledAccount.program); + expect(decompressed).toMatchObject(contracts.OpenZeppelinAccount.program); }); });