Change StarkNet to Starknet everywhere.

starkware-libs · Jan 28, 2025 · 73414f1 · 73414f1
1 parent 998e449
commit 73414f1
Show file tree

Hide file tree

Showing 24 changed files with 147 additions and 145 deletions.
diff --git a/corelib/src/starknet/account.cairo b/corelib/src/starknet/account.cairo
@@ -29,7 +29,7 @@ pub struct Call {
 ///
 /// This trait assumes that the calldata for invoke transactions is `Array<Call>`.
 /// This is the network standard following SNIP6.
-/// It is not enforced by StarkNet, but deviating from the standard interface may lead to
+/// It is not enforced by Starknet, but deviating from the standard interface may lead to
 /// incompatibility with standard tooling.
 #[starknet::interface]
 pub trait AccountContract<TContractState> {

diff --git a/crates/bin/get-lowering/Cargo.toml b/crates/bin/get-lowering/Cargo.toml
@@ -4,7 +4,7 @@ version.workspace = true
 edition.workspace = true
 repository.workspace = true
 license-file.workspace = true
-description = "Compiler executable for the Cairo programming language with the StarkNet plugin."
+description = "Compiler executable for the Cairo programming language with the Starknet plugin."
 
 [dependencies]
 anyhow.workspace = true

diff --git a/crates/bin/sierra-compile/src/main.rs b/crates/bin/sierra-compile/src/main.rs
@@ -30,7 +30,7 @@ fn main() -> anyhow::Result<()> {
         Err(err) => {
             anyhow::bail!(formatdoc! {"
             Failed to parse sierra program with: `{err:?}`.
-            Note: StarkNet contracts should be compiled with `starknet-sierra-compile`."
+            Note: Starknet contracts should be compiled with `starknet-sierra-compile`."
             })
         }
     };

diff --git a/crates/bin/starknet-compile/Cargo.toml b/crates/bin/starknet-compile/Cargo.toml
@@ -4,7 +4,7 @@ version.workspace = true
 edition.workspace = true
 repository.workspace = true
 license-file.workspace = true
-description = "Compiler executable for the Cairo programming language with the StarkNet plugin."
+description = "Compiler executable for the Cairo programming language with the Starknet plugin."
 
 [dependencies]
 anyhow.workspace = true

diff --git a/crates/bin/starknet-sierra-compile/Cargo.toml b/crates/bin/starknet-sierra-compile/Cargo.toml
@@ -4,7 +4,7 @@ version.workspace = true
 edition.workspace = true
 repository.workspace = true
 license-file.workspace = true
-description = "Compiler executable for the Sierra intermediate representation with StarkNet extensions"
+description = "Compiler executable for the Sierra intermediate representation with Starknet extensions"
 
 [dependencies]
 anyhow.workspace = true
@@ -14,4 +14,6 @@ serde_json.workspace = true
 
 cairo-lang-sierra = { path = "../../cairo-lang-sierra", version = "~2.9.2" }
 cairo-lang-starknet-classes = { path = "../../cairo-lang-starknet-classes", version = "~2.9.2" }
-cairo-lang-utils = { path = "../../cairo-lang-utils", version = "~2.9.2", features = ["serde"] }
+cairo-lang-utils = { path = "../../cairo-lang-utils", version = "~2.9.2", features = [
+    "serde",
+] }
diff --git a/crates/cairo-lang-sierra-ap-change/src/core_libfunc_ap_change.rs b/crates/cairo-lang-sierra-ap-change/src/core_libfunc_ap_change.rs
@@ -35,7 +35,7 @@ use cairo_lang_sierra::extensions::nullable::NullableConcreteLibfunc;
 use cairo_lang_sierra::extensions::pedersen::PedersenConcreteLibfunc;
 use cairo_lang_sierra::extensions::poseidon::PoseidonConcreteLibfunc;
 use cairo_lang_sierra::extensions::range::IntRangeConcreteLibfunc;
-use cairo_lang_sierra::extensions::starknet::StarkNetConcreteLibfunc;
+use cairo_lang_sierra::extensions::starknet::StarknetConcreteLibfunc;
 use cairo_lang_sierra::extensions::starknet::testing::TestingConcreteLibfunc;
 use cairo_lang_sierra::extensions::structure::StructConcreteLibfunc;
 use cairo_lang_sierra::ids::ConcreteTypeId;
@@ -302,46 +302,46 @@ pub fn core_libfunc_ap_change<InfoProvider: InvocationApChangeInfoProvider>(
         Poseidon(libfunc) => match libfunc {
             PoseidonConcreteLibfunc::HadesPermutation(_) => vec![ApChange::Known(0)],
         },
-        StarkNet(libfunc) => match libfunc {
-            StarkNetConcreteLibfunc::ClassHashConst(_)
-            | StarkNetConcreteLibfunc::ContractAddressConst(_) => vec![ApChange::Known(0)],
+        Starknet(libfunc) => match libfunc {
+            StarknetConcreteLibfunc::ClassHashConst(_)
+            | StarknetConcreteLibfunc::ContractAddressConst(_) => vec![ApChange::Known(0)],
 
-            StarkNetConcreteLibfunc::ClassHashTryFromFelt252(_)
-            | StarkNetConcreteLibfunc::ContractAddressTryFromFelt252(_)
-            | StarkNetConcreteLibfunc::StorageAddressTryFromFelt252(_) => {
+            StarknetConcreteLibfunc::ClassHashTryFromFelt252(_)
+            | StarknetConcreteLibfunc::ContractAddressTryFromFelt252(_)
+            | StarknetConcreteLibfunc::StorageAddressTryFromFelt252(_) => {
                 vec![ApChange::Known(5), ApChange::Known(6)]
             }
-            StarkNetConcreteLibfunc::ClassHashToFelt252(_)
-            | StarkNetConcreteLibfunc::ContractAddressToFelt252(_)
-            | StarkNetConcreteLibfunc::StorageAddressToFelt252(_) => vec![ApChange::Known(0)],
-            StarkNetConcreteLibfunc::StorageBaseAddressConst(_) => vec![ApChange::Known(0)],
-            StarkNetConcreteLibfunc::StorageBaseAddressFromFelt252(_) => {
+            StarknetConcreteLibfunc::ClassHashToFelt252(_)
+            | StarknetConcreteLibfunc::ContractAddressToFelt252(_)
+            | StarknetConcreteLibfunc::StorageAddressToFelt252(_) => vec![ApChange::Known(0)],
+            StarknetConcreteLibfunc::StorageBaseAddressConst(_) => vec![ApChange::Known(0)],
+            StarknetConcreteLibfunc::StorageBaseAddressFromFelt252(_) => {
                 vec![ApChange::Known(7)]
             }
-            StarkNetConcreteLibfunc::StorageAddressFromBase(_) => vec![ApChange::Known(0)],
-            StarkNetConcreteLibfunc::StorageAddressFromBaseAndOffset(_) => vec![ApChange::Known(0)],
-            StarkNetConcreteLibfunc::CallContract(_)
-            | StarkNetConcreteLibfunc::StorageRead(_)
-            | StarkNetConcreteLibfunc::StorageWrite(_)
-            | StarkNetConcreteLibfunc::EmitEvent(_)
-            | StarkNetConcreteLibfunc::GetBlockHash(_)
-            | StarkNetConcreteLibfunc::GetExecutionInfo(_)
-            | StarkNetConcreteLibfunc::GetExecutionInfoV2(_)
-            | StarkNetConcreteLibfunc::Deploy(_)
-            | StarkNetConcreteLibfunc::Keccak(_)
-            | StarkNetConcreteLibfunc::Sha256ProcessBlock(_)
-            | StarkNetConcreteLibfunc::LibraryCall(_)
-            | StarkNetConcreteLibfunc::ReplaceClass(_)
-            | StarkNetConcreteLibfunc::SendMessageToL1(_)
-            | StarkNetConcreteLibfunc::Secp256(_)
-            | StarkNetConcreteLibfunc::GetClassHashAt(_) => {
+            StarknetConcreteLibfunc::StorageAddressFromBase(_) => vec![ApChange::Known(0)],
+            StarknetConcreteLibfunc::StorageAddressFromBaseAndOffset(_) => vec![ApChange::Known(0)],
+            StarknetConcreteLibfunc::CallContract(_)
+            | StarknetConcreteLibfunc::StorageRead(_)
+            | StarknetConcreteLibfunc::StorageWrite(_)
+            | StarknetConcreteLibfunc::EmitEvent(_)
+            | StarknetConcreteLibfunc::GetBlockHash(_)
+            | StarknetConcreteLibfunc::GetExecutionInfo(_)
+            | StarknetConcreteLibfunc::GetExecutionInfoV2(_)
+            | StarknetConcreteLibfunc::Deploy(_)
+            | StarknetConcreteLibfunc::Keccak(_)
+            | StarknetConcreteLibfunc::Sha256ProcessBlock(_)
+            | StarknetConcreteLibfunc::LibraryCall(_)
+            | StarknetConcreteLibfunc::ReplaceClass(_)
+            | StarknetConcreteLibfunc::SendMessageToL1(_)
+            | StarknetConcreteLibfunc::Secp256(_)
+            | StarknetConcreteLibfunc::GetClassHashAt(_) => {
                 vec![ApChange::Known(2), ApChange::Known(2)]
             }
-            StarkNetConcreteLibfunc::Testing(libfunc) => match libfunc {
+            StarknetConcreteLibfunc::Testing(libfunc) => match libfunc {
                 TestingConcreteLibfunc::Cheatcode(_) => vec![ApChange::Known(2)],
             },
-            StarkNetConcreteLibfunc::Sha256StateHandleInit(_) => vec![ApChange::Known(0)],
-            StarkNetConcreteLibfunc::Sha256StateHandleDigest(_) => vec![ApChange::Known(0)],
+            StarknetConcreteLibfunc::Sha256StateHandleInit(_) => vec![ApChange::Known(0)],
+            StarknetConcreteLibfunc::Sha256StateHandleDigest(_) => vec![ApChange::Known(0)],
         },
         Nullable(libfunc) => match libfunc {
             NullableConcreteLibfunc::Null(_)

diff --git a/crates/cairo-lang-sierra-gas/src/core_libfunc_cost_base.rs b/crates/cairo-lang-sierra-gas/src/core_libfunc_cost_base.rs
@@ -425,7 +425,7 @@ pub fn core_libfunc_cost(
                 pre_cost: PreCost::builtin(CostTokenType::Poseidon),
             }],
         },
-        StarkNet(libfunc) => {
+        Starknet(libfunc) => {
             starknet_libfunc_cost_base(libfunc).into_iter().map(BranchCost::from).collect()
         }
         Nullable(libfunc) => match libfunc {

diff --git a/crates/cairo-lang-sierra-gas/src/starknet_libfunc_cost_base.rs b/crates/cairo-lang-sierra-gas/src/starknet_libfunc_cost_base.rs
@@ -1,6 +1,6 @@
 use std::vec;
 
-use cairo_lang_sierra::extensions::starknet::StarkNetConcreteLibfunc;
+use cairo_lang_sierra::extensions::starknet::StarknetConcreteLibfunc;
 use cairo_lang_sierra::extensions::starknet::secp256::{
     Secp256ConcreteLibfunc, Secp256OpConcreteLibfunc,
 };
@@ -12,51 +12,51 @@ const SYSTEM_CALL_STEPS: i32 = 100;
 pub const SYSTEM_CALL_COST: i32 =
     ConstCost { steps: SYSTEM_CALL_STEPS, holes: 0, range_checks: 0, range_checks96: 0 }.cost();
 
-/// Returns some cost value for a StarkNet libfunc - a helper function to implement costing both for
+/// Returns some cost value for a Starknet libfunc - a helper function to implement costing both for
 /// creating gas equations and getting actual gas cost after having a solution.
-pub fn starknet_libfunc_cost_base(libfunc: &StarkNetConcreteLibfunc) -> Vec<ConstCost> {
+pub fn starknet_libfunc_cost_base(libfunc: &StarknetConcreteLibfunc) -> Vec<ConstCost> {
     let steps = |value| ConstCost { steps: value, ..Default::default() };
     match libfunc {
-        StarkNetConcreteLibfunc::CallContract(_) => syscall_cost(4),
-        StarkNetConcreteLibfunc::ClassHashConst(_)
-        | StarkNetConcreteLibfunc::ContractAddressConst(_) => vec![steps(0)],
-        StarkNetConcreteLibfunc::ClassHashTryFromFelt252(_)
-        | StarkNetConcreteLibfunc::ContractAddressTryFromFelt252(_)
-        | StarkNetConcreteLibfunc::StorageAddressTryFromFelt252(_) => {
+        StarknetConcreteLibfunc::CallContract(_) => syscall_cost(4),
+        StarknetConcreteLibfunc::ClassHashConst(_)
+        | StarknetConcreteLibfunc::ContractAddressConst(_) => vec![steps(0)],
+        StarknetConcreteLibfunc::ClassHashTryFromFelt252(_)
+        | StarknetConcreteLibfunc::ContractAddressTryFromFelt252(_)
+        | StarknetConcreteLibfunc::StorageAddressTryFromFelt252(_) => {
             vec![ConstCost { steps: 7, holes: 0, range_checks: 3, range_checks96: 0 }, ConstCost {
                 steps: 9,
                 holes: 0,
                 range_checks: 3,
                 range_checks96: 0,
             }]
         }
-        StarkNetConcreteLibfunc::ClassHashToFelt252(_)
-        | StarkNetConcreteLibfunc::ContractAddressToFelt252(_)
-        | StarkNetConcreteLibfunc::StorageAddressToFelt252(_) => vec![steps(0)],
-        StarkNetConcreteLibfunc::StorageRead(_) => syscall_cost(2),
-        StarkNetConcreteLibfunc::StorageWrite(_) => syscall_cost(3),
-        StarkNetConcreteLibfunc::StorageBaseAddressConst(_) => vec![steps(0)],
-        StarkNetConcreteLibfunc::StorageBaseAddressFromFelt252(_) => {
+        StarknetConcreteLibfunc::ClassHashToFelt252(_)
+        | StarknetConcreteLibfunc::ContractAddressToFelt252(_)
+        | StarknetConcreteLibfunc::StorageAddressToFelt252(_) => vec![steps(0)],
+        StarknetConcreteLibfunc::StorageRead(_) => syscall_cost(2),
+        StarknetConcreteLibfunc::StorageWrite(_) => syscall_cost(3),
+        StarknetConcreteLibfunc::StorageBaseAddressConst(_) => vec![steps(0)],
+        StarknetConcreteLibfunc::StorageBaseAddressFromFelt252(_) => {
             vec![ConstCost { steps: 10, holes: 0, range_checks: 3, range_checks96: 0 }]
         }
-        StarkNetConcreteLibfunc::StorageAddressFromBase(_) => vec![steps(0)],
-        StarkNetConcreteLibfunc::StorageAddressFromBaseAndOffset(_) => vec![steps(0)],
-        StarkNetConcreteLibfunc::EmitEvent(_) => syscall_cost(4),
-        StarkNetConcreteLibfunc::GetBlockHash(_) => syscall_cost(1),
-        StarkNetConcreteLibfunc::GetExecutionInfo(_)
-        | StarkNetConcreteLibfunc::GetExecutionInfoV2(_) => syscall_cost(0),
-        StarkNetConcreteLibfunc::Deploy(_) => syscall_cost(5),
-        StarkNetConcreteLibfunc::Keccak(_) => syscall_cost(2),
-        StarkNetConcreteLibfunc::Sha256ProcessBlock(_) => syscall_cost(2),
-        StarkNetConcreteLibfunc::Sha256StateHandleInit(_) => vec![steps(0)],
-        StarkNetConcreteLibfunc::Sha256StateHandleDigest(_) => vec![steps(0)],
-        StarkNetConcreteLibfunc::LibraryCall(_) => syscall_cost(4),
-        StarkNetConcreteLibfunc::ReplaceClass(_) => syscall_cost(1),
-        StarkNetConcreteLibfunc::SendMessageToL1(_) => syscall_cost(3),
-        StarkNetConcreteLibfunc::Testing(libfunc) => match libfunc {
+        StarknetConcreteLibfunc::StorageAddressFromBase(_) => vec![steps(0)],
+        StarknetConcreteLibfunc::StorageAddressFromBaseAndOffset(_) => vec![steps(0)],
+        StarknetConcreteLibfunc::EmitEvent(_) => syscall_cost(4),
+        StarknetConcreteLibfunc::GetBlockHash(_) => syscall_cost(1),
+        StarknetConcreteLibfunc::GetExecutionInfo(_)
+        | StarknetConcreteLibfunc::GetExecutionInfoV2(_) => syscall_cost(0),
+        StarknetConcreteLibfunc::Deploy(_) => syscall_cost(5),
+        StarknetConcreteLibfunc::Keccak(_) => syscall_cost(2),
+        StarknetConcreteLibfunc::Sha256ProcessBlock(_) => syscall_cost(2),
+        StarknetConcreteLibfunc::Sha256StateHandleInit(_) => vec![steps(0)],
+        StarknetConcreteLibfunc::Sha256StateHandleDigest(_) => vec![steps(0)],
+        StarknetConcreteLibfunc::LibraryCall(_) => syscall_cost(4),
+        StarknetConcreteLibfunc::ReplaceClass(_) => syscall_cost(1),
+        StarknetConcreteLibfunc::SendMessageToL1(_) => syscall_cost(3),
+        StarknetConcreteLibfunc::Testing(libfunc) => match libfunc {
             TestingConcreteLibfunc::Cheatcode(_) => vec![steps(1)],
         },
-        StarkNetConcreteLibfunc::Secp256(libfunc) => {
+        StarknetConcreteLibfunc::Secp256(libfunc) => {
             match libfunc {
                 Secp256ConcreteLibfunc::K1(libfunc) => match libfunc {
                     Secp256OpConcreteLibfunc::New(_) => syscall_cost(4),
@@ -74,7 +74,7 @@ pub fn starknet_libfunc_cost_base(libfunc: &StarkNetConcreteLibfunc) -> Vec<Cons
                 },
             }
         }
-        StarkNetConcreteLibfunc::GetClassHashAt(_) => syscall_cost(1),
+        StarknetConcreteLibfunc::GetClassHashAt(_) => syscall_cost(1),
     }
 }
 

diff --git a/crates/cairo-lang-sierra-to-casm/src/invocations/mod.rs b/crates/cairo-lang-sierra-to-casm/src/invocations/mod.rs
@@ -698,7 +698,7 @@ pub fn compile_invocation(
         Felt252Dict(libfunc) => felt252_dict::build_dict(libfunc, builder),
         Pedersen(libfunc) => pedersen::build(libfunc, builder),
         Poseidon(libfunc) => poseidon::build(libfunc, builder),
-        StarkNet(libfunc) => starknet::build(libfunc, builder),
+        Starknet(libfunc) => starknet::build(libfunc, builder),
         Nullable(libfunc) => nullable::build(libfunc, builder),
         Debug(libfunc) => debug::build(libfunc, builder),
         SnapshotTake(_) => misc::build_dup(builder),