New Crowdin updates

docs/clarity/language-keywords.md

@@ -0,0 +1,147 @@
+---
+title: Keywords
+description: See a detailed list of all keywords for the Clarity language.
+sidebar_position: 4
+tags:
+  - clarity
+---
+
+![](/img/keywords.jpg)
+
+## Keyword reference
+
+Detailed list of all keywords for the Clarity language.
+
+### contract-caller
+
+#### output: `principal`
+
+#### description:
+
+Returns the caller of the current contract context. If this contract is the first one called by a signed transaction, the caller will be equal to the signing principal. If `contract-call?` was used to invoke a function from a new contract, `contract-caller` changes to the _calling_ contract's principal. If `as-contract` is used to change the `tx-sender` context, `contract-caller` _also_ changes to the same contract principal.
+
+#### example:
+
+```clarity
+(print contract-caller) ;; Will print out a Stacks address of the transaction sender
+```
+
+### tx-sender
+
+#### output: `principal`
+
+#### description:
+
+Returns the original sender of the current transaction, or if `as-contract` was called to modify the sending context, it returns that
+contract principal.
+
+#### example:
+
+```clarity
+(print tx-sender) ;; Will print out a Stacks address of the transaction sender
+```
+
+### block-height
+
+#### output: `uint`
+
+#### description:
+
+Returns the current block height of the Stacks blockchain as an uint
+
+#### example:
+
+```clarity
+(> block-height 1000) ;; returns true if the current block-height has passed 1000 blocks.
+```
+
+### burn-block-height
+
+#### output: `uint`
+
+#### description:
+
+Returns the current block height of the underlying burn blockchain as a uint
+
+#### example:
+
+```clarity
+(> burn-block-height 1000) ;; returns true if the current height of the underlying burn blockchain has passed 1000 blocks.
+```
+
+### none
+
+#### output: `(optional ?)`
+
+#### description:
+
+Represents the _none_ option indicating no value for a given optional (analogous to a null value).
+
+#### example:
+
+```clarity
+(define-public (only-if-positive (a int))
+  (if (> a 0)
+      (some a)
+      none))
+(only-if-positive 4) ;; Returns (some 4)
+(only-if-positive (- 3)) ;; Returns none
+```
+
+### true
+
+#### output: `bool`
+
+#### description:
+
+Boolean true constant.
+
+#### example:
+
+```clarity
+(and true false) ;; Evaluates to false
+(or false true)  ;; Evaluates to true
+```
+
+### false
+
+#### output: `bool`
+
+#### description:
+
+Boolean false constant.
+
+#### example:
+
+```clarity
+(and true false) ;; Evaluates to false
+(or false true)  ;; Evaluates to true
+```
+
+### stx-liquid-supply
+
+#### output: `uint`
+
+#### description:
+
+Returns the total number of micro-STX (uSTX) that are liquid in the system as of this block.
+
+#### example:
+
+```clarity
+(print stx-liquid-supply) ;; Will print out the total number of liquid uSTX
+```
+
+### is-in-regtest
+
+#### output: `bool`
+
+#### description:
+
+Returns whether or not the code is running in a regression test
+
+#### example:
+
+```clarity
+(print is-in-regtest) ;; Will print 'true' if the code is running in a regression test
+```

docs/stacks-academy/sips.md

@@ -17,7 +17,7 @@ The SIPs are located in the [stacksgov/sips](https://github.com/stacksgov/sips)
 Anyone in the Stacks community can submit a SIP.
 
 :::tip Stacks Improvement Proposals Community Calls
-Add the [weekly community SIP call](https://www.addevent.com/event/IJ15791776) to your calendar.
+Add the [weekly community SIP call](https://www.addevent.com/event/wS15955379) to your calendar.
 
 SIP Meeting calls are recorded and available [here](https://www.youtube.com/playlist?list=PLg717Ri_rTnx5kuaWqp3cUAtwQk_yzslT)
 
@@ -37,7 +37,10 @@ More details of the meetings are available [here](https://github.com/stacksgov/s
 - [x] [SIP 009: Standard Trait Definition for Non-Fungible Tokens](https://github.com/stacksgov/sips/blob/main/sips/sip-009/sip-009-nft-standard.md)
 - [x] [SIP 010: Standard Trait Definition for Fungible Tokens](https://github.com/stacksgov/sips/blob/main/sips/sip-010/sip-010-fungible-token-standard.md)
 - [x] [SIP 012: Burn Height Selection for a Network Upgrade to Introduce New Cost-Limits](https://github.com/stacksgov/sips/blob/main/sips/sip-012/sip-012-cost-limits-network-upgrade.md)
+- [x] [SIP-015: Stacks Upgrade of Proof-of-Transfer and Clarity](https://github.com/stacksgov/sips/blob/main/sips/sip-015/sip-015-network-upgrade.md)
 - [x] [SIP-016: Metadata for Tokens](https://github.com/stacksgov/sips/blob/main/sips/sip-016/sip-016-token-metadata.md)
+- [x] [SIP-018: Signed Structured Data](https://github.com/stacksgov/sips/blob/main/sips/sip-018/sip-018-signed-structured-data.md)
+- [x] [SIP-020: Bitwise Operations in Clarity](https://github.com/stacksgov/sips/blob/main/sips/sip-020/sip-020-bitwise-ops.md)
 
 ## How to Get Involved
 

i18n/de/docusaurus-plugin-content-docs/current/clarity/crash-course.md

@@ -0,0 +1,122 @@
+---
+title: Clarity Crash Course
+description: A quick introduction to the Clarity programming language
+sidebar_position: 1
+---
+
+You now understand why Clarity exists and what problems it was designed to solve. :::note  
+If you didn't read the previous section, go ahead and [do that first](./index.md).
+:::
+
+Now let's do a really quick introduction to Clarity so you can familiarize yourself with the language and syntax.
+
+This crash course is designed for people who have some experience with programming but are new to Clarity. You don't need smart contract development experience, but if you do, with something like Solidity, you'll pick this up really quick.
+
+Once you've familiarized yourself with the language, if you'd like to continue your journey and master Clarity to become a smart contract developer, we recommend either the book, [Clarity of Mind](https://book.clarity-lang.org/title-page.html), or the course, [Clarity Universe](https://clarity-lang.org/universe), which has both a self-paced and guided cohort-based version.
+
+## Your First Clarity Smart Contract
+
+We're going to build a basic Clarity smart contract using [Clarity Tools](https://clarity.tools/code/new), so you won't have to install anything for this introduction.
+
+Visit that link, and it will open up a new contract for you.
+
+![Clarity Tools New](tools-new.png)
+
+Already we can take a look at a few basic features of both Clarity and Clarity Tools. First, on the left you'll see that our Clarity code is being evaluated in real-time for us. This is really nice for experimenting and demonstrating basic Clarity code.
+
+Next up we can see our first bit of Clarity code.
+
+Those two semicolons are how we denote comments in Clarity.
+
+Then the next line down we have a public function declaration.
+
+Here is out first glimpse of Clarity's syntax, which may be new to you depending on your development background.
+
+For those new to Clarity, it's a little weird and uncomfortable at first, but one of the core design tenets of Clarity is simplicity and readability, and the more you work with it the more you come to appreciate the succinctness and _clarity_ (sorry) of the code you are writing.
+
+Clarity takes inspiration from LISP, and you can think of everything in Clarity as a list inside of a list, or an expression inside of an expression. Everything in Clarity is wrapped in parentheses, function definitions, variable declarations, function parameters, etc.
+
+So here we are saying that we want to:
+
+1. Call a function called `define-read-only`. This is a built-in function, one of many that you can refer to [in the docs](./language-functions.mdx).
+
+2. Pass it a parameter of hello, which corresponds to the method signature type.
+
+3. Pass it a parameter of "Hello", which corresponds to the function body.
+
+You can refer to the [`define-read-only`](https://docs.stacks.co/docs/write-smart-contracts/clarity-language/language-functions#define-read-only) documentation to see these parameters.
+
+Why am I describing this as if we are calling a function? Because we are, and it's an important concept in Clarity that everything is an expression inside of an expression.
+
+Let's expand on this concept a bit by deleting this and writing a new function.
+
+```clarity
+(define-data-var count int 0)
+(define-public (add-number (number int))
+    (let
+        (
+            (current-count count)
+        )
+
+        (var-set count (+ 1 number))
+        (ok (var-get count))
+    )
+)
+
+
+(add-number 5)
+```
+
+If you type that into Clarity Tools, you'll see the result that gets printed is 6.
+
+![Clarity Tools New](tools-new.png)
+
+Okay there are actually a lot of Clarity concepts packed into this simple code.
+
+Let's go over what this code is doing, and you'll pick up some Clarity concepts along the way.
+
+The first thing we are doing here is defining a new variable called `count` and setting its initial value to 0.
+
+This will be a persistent state variable, so this is actually getting written to the blockchain. If you are new to smart contract development, the fact that data is persisted within the file like this might take some getting used to.
+
+So if we were to write and deploy this contract (which you can do in the Stacks Explorer if you like), as soon as it gets deployed, it will run through the contract line by line executing anything at the root level.
+
+Remember that Clarity is interpreted, not compiled, so there's not compile step when developing Clarity contracts.
+
+So this `define-data-var` will be evaluated and the `count` variable will be initialized with a value of 0.
+
+Next we are defining a public function called `add-number`, which will be created (but not called) on deploy as well.
+
+:::note
+In Clarity, we have public, private, and read only functions. Public allow you to modify chain state and can be called from anywhere, private do the same except they can only be called from within the contract, and read only will fail if they attempt to modify state.
+:::
+
+This function is taking a single parameter, called `number` that is a type of `int`.
+
+Now, what is this `let` business all about? Remember that we said that everything in Clarity is an expression and declaring new functions is just a matter of calling the `define-public` function?
+
+Well the second argument to this is the function body, but it can only evaluate a single expression.
+
+So this `let` function is a way of wrapping a multi-step function into a single argument.
+
+But it does one other crucial thing at the beginning. This line:
+
+```clarity
+(current-count count)
+```
+
+Sets a variable that only exists in the context of this particular function. So here we are saying, create a new variable called `current-count` and set it equal to the value of `count`.
+
+Then we use that in our actual function body down below.
+
+In the next step we are setting the value of our `count` variable to 1 plus whatever number we passed in. The `+` is just another call to a function where the parameters are the numbers we want to add.
+
+Then, finally, we are returning the new value of `count` with our `ok` response, indicating that the function completed successfully.
+
+Then in the very last line we are actually calling this function, passing in 5.
+
+This was a very brief overview of Clarity just to get your feet wet and give you a taste of how it works.
+
+If you are interested in diving into the details, we highly recommend going through either the [Clarity Book](https://book.clarity-lang.org/title-page.html) or [Clarity Universe](https://clarity-lang.org/universe), depending on your learning style.
+
+If you prefer to dive directly into the docs, you can continue on ahead and check out the types, keywords, and functions available in Clarity, as well as a few sample contracts.

i18n/de/docusaurus-plugin-content-docs/current/clarity/index.md

@@ -0,0 +1,58 @@
+---
+title: Clarity Overview
+description: Overview and guides for getting started with Clarity
+sidebar_label: Clarity
+sidebar_position: 5
+---
+
+Clarity is a **decidable** smart contract language that optimizes for predictability and security, designed for the Stacks blockchain. Smart contracts allow developers to encode essential business logic on a blockchain.
+
+The design decisions behind Clarity were based heavily on taking lessons learned in common Solidity exploits and creating a language that has been purpose-built for safety and security in mind.
+
+These docs serve primarily as a reference for the functions and keywords that you can use in Clarity.
+
+In order to learn Clarity, we recommend diving into the [Clarity of Mind](https://book.clarity-lang.org/), an online book to teach you everything you need to know to build robust smart contracts, or joining a [Clarity Camp](https://clarity-lang.org/universe#camp), the cohort-based immersive Clarity experience.
+
+## What makes Clarity different
+
+The following section is an excerpt from the excellent book, [Clarity of Mind](https://book.clarity-lang.org/ch00-00-introduction.html):
+
+The number of smart contract languages grows by the year. Choosing a first language can be challenging, especially for a beginner. The choice is largely dictated by the ecosystem you are interested in, although some languages are applicable to more than just one platform. Each language has its own upsides and downsides and it is out of the scope of this book to look at all of them. Instead, we will focus on what sets Clarity apart and why it is a prime choice if you require the utmost security and transparency.
+
+One of the core precepts of Clarity is that it is secure by design. The design process was guided by examining common pitfalls, mistakes, and vulnerabilities in the field of smart contract engineering as a whole. There are countless real world examples of where developer failure led to the loss or theft of vast amounts of tokens. To name two big ones: an issue that has become known as the Parity bug led to the irreparable loss of millions of dollars worth of Ethereum. Second, the hacking of The DAO (a "Decentralized Autonomous Organization") caused financial damage so great that the Ethereum Foundation decided to issue a contentious hard fork that undid the theft. These and many other mistakes could have been prevented in the design of the language itself.
+
+### Clarity is interpreted, not compiled
+
+Clarity code is interpreted and committed to the chain exactly as written. Solidity and other languages are compiled to byte-code before it is submitted to the chain. The danger of compiled smart contract languages is two-fold: first, a compiler adds a layer of complexity. A bug in the compiler may lead to different byte-code than was intended and thus carries the risk of introducing a vulnerability. Second, byte-code is not human-readable, which makes it very hard to verify what the smart contract is actually doing. Ask yourself, would you sign a contract you cannot read? If your answer is no, then why should it be any different for smart contracts?2 With Clarity, what you see is what you get.
+
+### Clarity is decidable
+
+A decidable language has the property that from the code itself, you can know with certainty what the program will do. This avoids issues like the halting problem. With Clarity you know for sure that given any input, the program will halt in a finite number of steps. In simple terms: it is guaranteed that program execution will end. Decidability also allows for complete static analysis of the call graph so you get an accurate picture of the exact cost before execution. There is no way for a Clarity call to "run out of gas" in the middle of the call. We explore this idea more, along with a discussion on Turing completeness, in the [security deep dive on decidability](./security/decidable.md).
+
+### Clarity does not permit reentrancy
+
+Reentrancy is a situation where one smart contract calls into another, which then calls back into the first contract—the call "re-enters" the same logic. It may allow an attacker to trigger multiple token withdrawals before the contract has had a chance to update its internal balance sheet. Clarity's design considers reentrancy an anti-feature and disallows it on the language level.
+
+### Clarity guards against overflow and underflows
+
+Overflows and underflows happen when a calculation results in a number that is either too large or too small to be stored, respectively. These events throw smart contracts into disarray and may intentionally be triggered in poorly written contracts by attackers. Usually this leads to a situation where the contract is either frozen or drained of tokens. Overflows and underflows of any kind automatically cause a transaction to be aborted in Clarity.
+
+### Support for custom tokens is built-in
+
+Issuance of custom fungible and non-fungible tokens is a popular use-case for smart contracts. Custom token features are built into the Clarity language. Developers do not need to worry about creating an internal balance sheet, managing supply, and emitting token events. Creating custom tokens is covered in depth in later chapters.
+
+### On Stacks, transactions are secured by post conditions
+
+In order to further safeguard user tokens, post conditions can be attached to transactions to assert the chain state has changed in a certain way once the transaction has completed. For example, a user calling into a smart contract may attach a post condition that states that after the call completes, exactly 500 STX should have been transferred from one address to another. If the post condition check fails, then the entire transaction is reverted. Since custom token support is built right into Clarity, post conditions can also be used to guard any other token in the same way.
+
+### Returned responses cannot be left unchecked
+
+Public contract calls must return a so-called response that indicates success or failure. Any contract that calls another contract is required to properly handle the response. Clarity contracts that fail to do so are invalid and cannot be deployed on the network. Other languages like Solidity permit the use of low level calls without requiring the return value to be checked. For example, a token transfer can fail silently if the developer forgets to check the result. In Clarity it is not possible to ignore errors, although that obviously does prevent buggy error handling on behalf of the developer. Responses and error handling are covered extensively in the chapters on functions and control flow.
+
+### Composition over inheritance
+
+Clarity adopts a composition over inheritance. It means that Clarity smart contracts do not inherit from one another like you see in languages like Solidity. Developers instead define traits which are then implemented by different smart contracts. It allows contracts to conform to different interfaces with greater flexibility. There is no need to worry about complex class trees and contracts with implicit inherited behavior.
+
+### Access to the base chain: Bitcoin
+
+Clarity smart contracts can read the state of the Bitcoin base chain. It means you can use Bitcoin transactions as a trigger in your smart contracts! Clarity also features a number of built-in functions to verify secp256k1 signatures and recover keys.