fix links

docs/3.tutorials/crosswords/01-basics/01-set-up-skeleton.md

@@ -3,6 +3,7 @@ sidebar_position: 2
 sidebar_label: "Set up Rust and a contract skeleton" 
 title: "Set up Rust, get a NEAR testnet account, NEAR CLI, and get a basic smart contract skeleton ready"
 ---
+import {Github} from "@site/src/components/codetabs"
 
 # Getting started
 
@@ -91,9 +92,7 @@ By changing the `name` here, we'll be changing the compiled Wasm file's name aft
 
 Now let's look at our main file, in `src/lib.rs`:
 
-```rust reference
-https://github.com/near/boilerplate-template-rs/blob/f1edeead98a9ec12c3f6db311f62025305f57874/contract/src/lib.rs#L8-L44
-```
+<Github language="rust" start="8" end="44" url="https://github.com/near/boilerplate-template-rs/blob/f1edeead98a9ec12c3f6db311f62025305f57874/contract/src/lib.rs" />
 
 As you can see, this is a stub that's ready to be filled in. Let's pause and point out a few items:
 

docs/3.tutorials/crosswords/01-basics/02-add-functions-call.md

@@ -3,6 +3,7 @@ sidebar_position: 3
 sidebar_label: "Add basic code, create a subaccount, and call methods"
 title: "Alter the smart contract, learning about basics of development"
 ---
+import {Github} from "@site/src/components/codetabs"
 
 import teachingDeployment from '/docs/assets/crosswords/teaching--jeheycell.near--artcultureac.jpeg';
 import createAccount from '/docs/assets/crosswords/creating account with text--seanpineda.near--_seanpineda.png';
@@ -16,9 +17,7 @@ This section will modify the smart contract skeleton from the previous section.
 
 Let's modify the contract to be:
 
-```rust reference
-https://github.com/near-examples/crossword-snippets/blob/00223633f3e6b5b7137097e996b0aee90d632b0f/src/lib.rs#L1-L29
-```
+<Github language="rust" start="1" end="29" url="https://github.com/near-examples/crossword-snippets/blob/00223633f3e6b5b7137097e996b0aee90d632b0f/src/lib.rs" />
 
 We've done a few things here:
 1. Set a constant for the puzzle number.

docs/3.tutorials/crosswords/01-basics/03-hashing-and-unit-tests.md

@@ -3,6 +3,7 @@ sidebar_position: 4
 sidebar_label: "Hash the solution, unit tests, and an init method"
 title: "Introduction to basic hashing and adding unit tests"
 ---
+import {Github} from "@site/src/components/codetabs"
 
 import batchCookieTray from '/docs/assets/crosswords/batch-of-actions--dobulyo.near--w_artsu.jpg';
 
@@ -26,9 +27,7 @@ As mentioned in the first section of this **Basics** chapter, our smart contract
 
 We'll add a dependency to the [hex crate](https://crates.io/crates/hex) to make things easier. As you may remember, dependencies live in the manifest file.
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-1/blob/481a83f0c90398f3234ce8006af4e232d6c779d7/contract/Cargo.toml#L10-L12
-```
+<Github language="rust" start="10" end="12" url="https://github.com/near-examples/crossword-tutorial-chapter-1/blob/481a83f0c90398f3234ce8006af4e232d6c779d7/contract/Cargo.toml" />
 
 Let's write a unit test that acts as a helper during development. This unit test will sha256 hash the input **"near nomicon ref finance"** and print it in a human-readable, hex format. (We'll typically put unit tests at the bottom of the `lib.rs` file.)
 
@@ -89,9 +88,7 @@ The unit test above is meant for debugging and quickly running snippets of code.
 
 Let's add this unit test (inside the `mod tests {}` block, under our previous unit test) and analyze it:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-1/blob/d7699cf35092024fe11719b68788436c82fe82af/contract/src/lib.rs#L63-L93
-```
+<Github language="rust" start="63" end="93" url="https://github.com/near-examples/crossword-tutorial-chapter-1/blob/d7699cf35092024fe11719b68788436c82fe82af/contract/src/lib.rs" />
 
 The first few lines of code will be used commonly when writing unit tests. It uses the `VMContextBuilder` to create some basic context for a transaction, then sets up the testing environment.
 
@@ -119,9 +116,7 @@ Let's have the solution be set once, right after deploying the smart contract.
 
 Here we'll use the [`#[near_bindgen]` macro](https://docs.rs/near-sdk/latest/near_sdk/attr.near_bindgen.html) on a function called `new`, which is a common pattern.
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-1/blob/94f42e75cf70ed2aafb9c29a1faa1e21f079a49e/contract/src/lib.rs#L10-L17
-```
+<Github language="rust" start="10" end="17" url="https://github.com/near-examples/crossword-tutorial-chapter-1/blob/94f42e75cf70ed2aafb9c29a1faa1e21f079a49e/contract/src/lib.rs" />
 
 Let's call this method on a fresh contract.
 
@@ -156,9 +151,7 @@ This is close to what we want, but what if a person deploys their smart contract
 Batch Actions are common in this instance, where we want to deploy and call an initialization function. They're also common when using a factory pattern, where a subaccount is created, a smart contract is deployed to it, a key is added, and a function is called.
 
 Here's a truncated snippet from a useful (though somewhat advanced) repository with a wealth of useful code:
-```rust reference
-https://github.com/near/core-contracts/blob/1720c0cfee238974ebeae8ad43076abeb951504f/staking-pool-factory/src/lib.rs#L172-L177
-```
+<Github language="rust" start="172" end="177" url="https://github.com/near/core-contracts/blob/1720c0cfee238974ebeae8ad43076abeb951504f/staking-pool-factory/src/lib.rs" />
 
 We'll get into Actions later in this tutorial, but in the meantime here's a handy [reference from the spec](https://nomicon.io/RuntimeSpec/Actions.html).
 :::
@@ -192,9 +185,7 @@ In the next section we'll add a simple frontend for our single, hardcoded crossw
 
 We'll also modify our `guess_solution` to return a boolean value, which will also make things easier for our frontend.
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-1/blob/94f42e75cf70ed2aafb9c29a1faa1e21f079a49e/contract/src/lib.rs#L19-L34
-```
+<Github language="rust" start="19" end="34" url="https://github.com/near-examples/crossword-tutorial-chapter-1/blob/94f42e75cf70ed2aafb9c29a1faa1e21f079a49e/contract/src/lib.rs" />
 
 The `get_solution` method can be called with:
 

docs/3.tutorials/crosswords/02-beginner/01-collections.md

@@ -3,6 +3,7 @@ sidebar_position: 2
 sidebar_label: "Store multiple puzzles"
 title: "Store multiple crossword puzzles using a specialized collection in NEAR called a LookupMap"
 ---
+import {Github} from "@site/src/components/codetabs"
 
 import bookPagination from '/docs/assets/crosswords/paging-through-hashes-swing--pierced_staggg.near--pierced_stag.jpg';
 import guardsAroundContract from '/docs/assets/crosswords/guards-contract-permissions--connoisseur_dane.near--connoisseurdane.png';
@@ -51,19 +52,15 @@ The name of the struct doesn't matter and there's nothing special about naming i
 
 Here's how our struct will look with the iterable and non-iterable NEAR collections:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-2/blob/276217ad82c64c610148e998ec926942ba910a12/contract/src/lib.rs#L73-L79
-```
+<Github language="rust" start="73" end="79" url="https://github.com/near-examples/crossword-tutorial-chapter-2/blob/276217ad82c64c610148e998ec926942ba910a12/contract/src/lib.rs" />
 
 Above, we have the `puzzles` and `unsolved_puzzles` fields which are collections.
 
 We also have an `owner_id` so we can exercise a common pattern in smart contract development: implementing a rudimentary permission system which can restrict access to certain functions. We'll expand on this thought in a moment.
 
 The snippet below shows the first method in the implementation of the `Crossword` struct, where the `new` function sets up these two specialized collections.
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-2/blob/276217ad82c64c610148e998ec926942ba910a12/contract/src/lib.rs#L81-L90
-```
+<Github language="rust" start="81" end="90" url="https://github.com/near-examples/crossword-tutorial-chapter-2/blob/276217ad82c64c610148e998ec926942ba910a12/contract/src/lib.rs" />
 
 So during the initialization function (`new`) we're setting the `owner_id`. For our purposes the owner will likely be the contract itself, but there can be several reasons to have it be a DAO or another user. Next, let's look at the `b"c"` and `b"u"` bits for the collection fields.
 
@@ -75,9 +72,7 @@ Let's take a peek at how we'll add a new crossword puzzle. Note that there will
 
 Unlike the previous chapter where there was only one crossword puzzle, we'll be inserting into our new collections, so let's create a `new_puzzle` method.
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-2/blob/8ec941c82539e6eafa4971444e1da9e4819330d3/contract/src/lib.rs#L147-L163
-```
+<Github language="rust" start="147" end="163" url="https://github.com/near-examples/crossword-tutorial-chapter-2/blob/8ec941c82539e6eafa4971444e1da9e4819330d3/contract/src/lib.rs" />
 
 Now we're set up to store multiple puzzles!
 

docs/3.tutorials/crosswords/02-beginner/03-actions.md

@@ -3,6 +3,7 @@ sidebar_position: 4
 sidebar_label: "Actions and sending NEAR"
 title: "There are several Actions an account can do, including sending the winner of the crossword puzzle NEAR using the Transfer Action"
 ---
+import {Github} from "@site/src/components/codetabs"
 
 import allActions from '/docs/assets/crosswords/crossword-actions.png';
 import transferNEAR from '/docs/assets/crosswords/transfer-brand-blue--qiqi04.near--blankworl.png';
@@ -49,9 +50,7 @@ Let's make it simple and hardcode the prize amount. This is how much NEAR will b
 
 At the top of the `lib.rs` file we'll add this constant:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-2/blob/1909630a10291081cb00b2780c1ae8889d98f620/contract/src/lib.rs#L10-L11
-```
+<Github language="rust" start="10" end="11" url="https://github.com/near-examples/crossword-tutorial-chapter-2/blob/1909630a10291081cb00b2780c1ae8889d98f620/contract/src/lib.rs" />
 
 As the code comment mentions, this is 5 NEAR, but look at all those zeroes in the code!
 
@@ -66,9 +65,7 @@ That's the value in yoctoNEAR. This concept is similar to other blockchains. Bit
 
 In the last chapter we had a simple function called `guess_solution` that returned `true` if the solution was correct, and `false` otherwise. We'll be replacing that function with `submit_solution` as shown below:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-2/blob/83d4d8925e6d30e04e8e4cb5e9a0a6d3763fce40/contract/src/lib.rs#L92-L124
-```
+<Github language="rust" start="92" end="124" url="https://github.com/near-examples/crossword-tutorial-chapter-2/blob/83d4d8925e6d30e04e8e4cb5e9a0a6d3763fce40/contract/src/lib.rs" />
 
 Note the last line in this function, which sends NEAR to the predecessor.
 

docs/3.tutorials/crosswords/03-intermediate/03-linkdrop.md

@@ -3,6 +3,7 @@ sidebar_position: 4
 sidebar_label: "Linkdrop contract"
 title: "Introducing the linkdrop contract we can use"
 ---
+import {Github} from "@site/src/components/codetabs"
 
 import createMainnetAccount from '/docs/assets/crosswords/create-mainnet-account.png';
 import createTestnetAccount from '/docs/assets/crosswords/create-testnet-wallet-account.png';
@@ -51,9 +52,7 @@ We'll want to write a smart contract that calls that same method. However, thing
 
 Here, we'll show the implementation of the `create_account` method. Note the `#[payable]` macro, which allows this function to accept an attached deposit. (Remember in the CLI command we were attaching 15 Ⓝ.)
 
-```rust reference
-https://github.com/near/near-linkdrop/blob/ba94a9c7292d3b48a0a8ba380fb0e7ff6b24efc6/src/lib.rs#L125-L149
-```
+<Github language="rust" start="125" end="149" url="https://github.com/near/near-linkdrop/blob/ba94a9c7292d3b48a0a8ba380fb0e7ff6b24efc6/src/lib.rs" />
 
 The most important part of the snippet above is around the middle where there's:
 
@@ -88,15 +87,11 @@ In other programming languages promises might work like this, but we must use ca
 
 Now let's look at the callback:
 
-```rust reference
-https://github.com/near/near-linkdrop/blob/ba94a9c7292d3b48a0a8ba380fb0e7ff6b24efc6/src/lib.rs#L151-L164
-```
+<Github language="rust" start="151" end="164" url="https://github.com/near/near-linkdrop/blob/ba94a9c7292d3b48a0a8ba380fb0e7ff6b24efc6/src/lib.rs" />
 
 This calls the private helper method `is_promise_success`, which basically checks to see that there was only one promise result, because we only attempted one Promise:
 
-```rust reference
-https://github.com/near/near-linkdrop/blob/ba94a9c7292d3b48a0a8ba380fb0e7ff6b24efc6/src/lib.rs#L32-L42
-```
+<Github language="rust" start="32" end="42" url="https://github.com/near/near-linkdrop/blob/ba94a9c7292d3b48a0a8ba380fb0e7ff6b24efc6/src/lib.rs" />
 
 Note that the callback returns a boolean. This means when we modify our crossword puzzle to call the linkdrop contract on `testnet`, we'll be able to determine if the account creation succeeded or failed.
 

docs/3.tutorials/crosswords/03-intermediate/04-cross-contract-calls.md

@@ -3,6 +3,7 @@ sidebar_position: 5
 sidebar_label: "Cross-contract calls, etc."
 title: "Adding cross-contract calls, access key shuffling, etc."
 ---
+import {Github} from "@site/src/components/codetabs"
 
 # Updating the contract
 
@@ -45,9 +46,7 @@ The previous chapter [we discussed enums](../02-beginner/02-structs-enums.md#usi
 
 First, let's see how the `submit_solution` will verify the correct solution.
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs#L145-L151
-```
+<Github language="rust" start="145" end="151" url="https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs" />
 
 Instead of hashing the plaintext, we simply check that the public key matches what we know the answer is. (The answer being the series of words representing the solution to the crossword puzzle, used as a seed phrase to create a key pair, including a public key.)
 
@@ -59,9 +58,7 @@ Further down in the `submit_solution` method we'll follow our plan by **adding a
 </figure>
 <br/>
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs#L175-L181
-```
+<Github language="rust" start="175" end="181" url="https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs" />
 
 The first promise above adds an access key, and the second deletes the access key on the account that was derived from the solution as a seed phrase.
 
@@ -84,9 +81,7 @@ Both functions will do cross-contract calls and use callbacks to see the result.
 
 We're going to be making a cross-contract call to the linkdrop account deployed to the `testnet` account. We're also going to have callbacks for that, and for a simple transfer to a (potentially existing) account. We'll create the traits that define both those methods.
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs#L19-L45
-```
+<Github language="rust" start="19" end="45" url="https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs" />
 
 :::tip
 It's not necessary to create the trait for the callback as we could have just implemented the functions `callback_after_transfer` and `callback_after_create_account` in our `Crossword` struct implementation. We chose to define the trait and implement it to make the code a bit more readable.
@@ -138,9 +133,7 @@ This `claim_reward` method will attempt to use the `Transfer` Action to send NEA
 
 Let's see how we check this in the callback:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs#L381-L411
-```
+<Github language="rust" start="381" end="411" url="https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs" />
 
 :::info The `#[private]` macro
 Notice that above the function, we have declared it to be private.
@@ -191,9 +184,7 @@ pub fn claim_reward_new_account(
 
 Then the callback:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs#L413-L448
-```
+<Github language="rust" start="413" end="448" url="https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs" />
 
 In the above snippet, there's one difference from the callback we saw in `claim_reward`: we capture the value returned from the smart contract we just called. Since the linkdrop contract returns a bool, we can expect that type. (See the comments with "NOTE:" above, highlighting this.)
 

docs/3.tutorials/crosswords/03-intermediate/05-base64vecu8.md

@@ -3,6 +3,7 @@ sidebar_position: 6
 sidebar_label: "Base64 params, wrap up"
 title: "Using base64-encoded arguments when we create a new crossword puzzle"
 ---
+import {Github} from "@site/src/components/codetabs"
 
 # Final modifications
 
@@ -22,15 +23,11 @@ Read more [about it here](/sdk/rust/contract-interface/serialization-interface#b
 
 First we'll set up a struct for the arguments we're expecting:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs#L111-L117
-```
+<Github language="rust" start="111" end="117" url="https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs" />
 
 Then we modify our `new_puzzle` method like so:
 
-```rust reference
-https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs#L290-L297
-```
+<Github language="rust" start="290" end="297" url="https://github.com/near-examples/crossword-tutorial-chapter-3/blob/ec07e1e48285d31089b7e8cec9e9cf32a7e90c35/contract/src/lib.rs" />
 
 We can take our original arguments and base64 encode them, using whatever method you prefer. There are plenty of online tool, Terminal commands, and open source applications like [Boop](https://boop.okat.best).