├── .claspignore
├── .github
    ├── PULL_REQUEST_TEMPLATE.md
    └── workflows
    │   └── trunk-check.yaml
├── .gitignore
├── .trunk
    ├── .gitignore
    ├── configs
    │   ├── .isort.cfg
    │   ├── .markdownlint.yaml
    │   ├── .prettierrc.json
    │   ├── .yamllint.yaml
    │   └── ruff.toml
    └── trunk.yaml
├── .vscode
    └── launch.json
├── README.md
├── appsscript.json
├── cairo0
    ├── builtins
    │   ├── bitwise_builtin.cairo
    │   ├── ecop_builtin.cairo
    │   ├── keccak_builtin.cairo
    │   ├── pedersen_builtin.cairo
    │   ├── poseidon_builtin.cairo
    │   ├── range_check96_builtin.cairo
    │   └── range_check_builtin.cairo
    ├── dict.cairo
    ├── fibonacci
    │   ├── fibonacci.cairo
    │   └── main.cairo
    ├── main.cairo
    ├── main_memory.bin
    └── main_trace.bin
├── package-lock.json
├── package.json
├── pyproject.toml
├── src
    ├── builtins
    │   ├── bitwise
    │   │   └── bitwise.ts
    │   ├── ec_op
    │   │   ├── ec_op.ts
    │   │   └── modular_ar.ts
    │   ├── ecdsa
    │   │   └── ecdsa.ts
    │   ├── keccak
    │   │   ├── keccak_f1600.ts
    │   │   └── keccak_utils.ts
    │   ├── pedersen
    │   │   ├── constants.ts
    │   │   └── pedersen.ts
    │   ├── poseidon
    │   │   ├── constants.ts
    │   │   └── poseidon.ts
    │   ├── range_check
    │   │   └── range_check.ts
    │   └── range_check96
    │   │   └── range_check96.ts
    ├── tests.ts
    ├── ui
    │   ├── Code.ts
    │   ├── api.ts
    │   ├── dialog.html
    │   ├── tutorials
    │   │   ├── fibonacci
    │   │   │   ├── program.ts
    │   │   │   └── steps.ts
    │   │   └── tutorials.ts
    │   └── ui.ts
    ├── utils.ts
    └── vm
    │   ├── constants.ts
    │   ├── errors.ts
    │   ├── instructions.ts
    │   └── vm.ts
├── tsconfig.json
└── uv.lock


/.claspignore:
--------------------------------------------------------------------------------
1 | .git/**/*
2 | .trunk/**/*
3 | node_modules/**/*
4 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | <!--- Please provide a general summary of your changes in the title -->
 2 | 
 3 | # Pull Request Title [TO BE UPDATED]
 4 | 
 5 | <!-- Give an estimate of the time you spent on this PR in terms of work days.
 6 | Did you spend 0.5 days on this PR or rather 2 days?  -->
 7 | 
 8 | Time spent on this PR:
 9 | 
10 | ## Pull request type
11 | 
12 | <!-- Please try to limit your pull request to one type,
13 | submit multiple pull requests if needed. -->
14 | 
15 | Please check the type of change your PR introduces:
16 | 
17 | - [ ] Bugfix
18 | - [ ] Feature
19 | - [ ] Code style update (formatting, renaming)
20 | - [ ] Refactoring (no functional changes, no api changes)
21 | - [ ] Build related changes
22 | - [ ] Documentation content changes
23 | - [ ] Other (please describe):
24 | 
25 | ## What is the current behavior?
26 | 
27 | <!-- Please describe the current behavior that you are modifying,
28 | or link to a relevant issue. -->
29 | 
30 | Resolves #<Issue number>
31 | 
32 | ## What is the new behavior?
33 | 
34 | <!-- Please describe the behavior or changes that are being added by this PR. -->
35 | 


--------------------------------------------------------------------------------
/.github/workflows/trunk-check.yaml:
--------------------------------------------------------------------------------
 1 | name: Trunk
 2 | 
 3 | on: [pull_request]
 4 | 
 5 | concurrency:
 6 |   group: ${{ github.workflow }}-${{ github.ref }}
 7 |   cancel-in-progress: true
 8 | 
 9 | permissions: read-all
10 | 
11 | jobs:
12 |   trunk_check:
13 |     name: Trunk Check Runner
14 |     runs-on: ubuntu-latest
15 |     permissions:
16 |       checks: write # For trunk to post annotations
17 |       contents: read # For repo checkout
18 | 
19 |     steps:
20 |       - name: Checkout
21 |         uses: actions/checkout@v3
22 |       - name: Trunk Check
23 |         uses: trunk-io/trunk-action@v1
24 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .clasprc.json
2 | .clasp.json
3 | .venv
4 | creds.json
5 | node_modules
6 | 


--------------------------------------------------------------------------------
/.trunk/.gitignore:
--------------------------------------------------------------------------------
 1 | *out
 2 | *logs
 3 | *actions
 4 | *notifications
 5 | *tools
 6 | plugins
 7 | user_trunk.yaml
 8 | user.yaml
 9 | tmp
10 | 


--------------------------------------------------------------------------------
/.trunk/configs/.isort.cfg:
--------------------------------------------------------------------------------
1 | [settings]
2 | profile=black
3 | 


--------------------------------------------------------------------------------
/.trunk/configs/.markdownlint.yaml:
--------------------------------------------------------------------------------
 1 | # Autoformatter friendly markdownlint config (all formatting rules disabled)
 2 | default: true
 3 | blank_lines: false
 4 | bullet: false
 5 | html: false
 6 | indentation: false
 7 | line_length: false
 8 | spaces: false
 9 | url: false
10 | whitespace: false
11 | 


--------------------------------------------------------------------------------
/.trunk/configs/.prettierrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "proseWrap": "always"
3 | }
4 | 


--------------------------------------------------------------------------------
/.trunk/configs/.yamllint.yaml:
--------------------------------------------------------------------------------
1 | rules:
2 |   quoted-strings:
3 |     required: only-when-needed
4 |     extra-allowed: ["{|}"]
5 |   key-duplicates: {}
6 |   octal-values:
7 |     forbid-implicit-octal: true
8 | 


--------------------------------------------------------------------------------
/.trunk/configs/ruff.toml:
--------------------------------------------------------------------------------
1 | # Generic, formatter-friendly config.
2 | select = ["B", "D3", "E", "F"]
3 | 
4 | # Never enforce `E501` (line length violations). This should be handled by formatters.
5 | ignore = ["E501"]
6 | 


--------------------------------------------------------------------------------
/.trunk/trunk.yaml:
--------------------------------------------------------------------------------
 1 | # This file controls the behavior of Trunk: https://docs.trunk.io/cli
 2 | # To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
 3 | version: 0.1
 4 | cli:
 5 |   version: 1.22.10
 6 | # Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins)
 7 | plugins:
 8 |   sources:
 9 |     - id: trunk
10 |       ref: v1.6.7
11 |       uri: https://github.com/trunk-io/plugins
12 | # Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
13 | runtimes:
14 |   enabled:
15 |     - node@18.20.5
16 |     - python@3.10.8
17 | # This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
18 | lint:
19 |   enabled:
20 |     - actionlint@1.7.7
21 |     - bandit@1.8.2
22 |     - black@25.1.0
23 |     - isort@6.0.0
24 |     - osv-scanner@1.9.2
25 |     - ruff@0.9.5
26 |     - taplo@0.9.3
27 |     - yamllint@1.35.1
28 |     - checkov@3.2.369
29 |     - git-diff-check
30 |     - markdownlint@0.44.0
31 |     - prettier@3.5.0
32 |     - trufflehog@3.88.5
33 | actions:
34 |   disabled:
35 |     - trunk-announce
36 |     - trunk-check-pre-push
37 |     - trunk-fmt-pre-commit
38 |   enabled:
39 |     - trunk-upgrade-available
40 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   // Use IntelliSense to learn about possible attributes.
 3 |   // Hover to view descriptions of existing attributes.
 4 |   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 |   "version": "0.2.0",
 6 |   "configurations": [
 7 |     {
 8 |       "name": "Debug cairo-compile",
 9 |       "type": "debugpy",
10 |       "request": "launch",
11 |       "program": "${command:python.interpreterPath}/../cairo-compile",
12 |       "args": [
13 |         "cairo0/main.cairo",
14 |         "--output",
15 |         "cairo0/main_compiled.json",
16 |         "--cairo_path",
17 |         "cairo0"
18 |       ],
19 |       "console": "integratedTerminal",
20 |       "justMyCode": false
21 |     }
22 |   ]
23 | }
24 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Cairo VM gs
  2 | 
  3 | ## Wat Cairo VM
  4 | 
  5 | Cairo VM stands for Cairo Virtual Machine (VM). Cairo stands for CPU AIR and is
  6 | a Turing complete, STARK friendly, CPU like instruction set and programming
  7 | language. At a high level, it lets the developer write program as with any other
  8 | programming language, but provable programs.
  9 | 
 10 | What is a provable program? Well, a program for which a given execution can be
 11 | proven without the need to re-execute it. In other words, with a provable
 12 | program P, you can run P on a given input I, returning output O, and convince
 13 | anyone that P(I) = O in logarithmic time. An application can be for example that
 14 | you delegate some heavy computation of cost N to a given cloud provider, and can
 15 | verify in cost (log N)^2 that they actually did the job and not just returned a
 16 | random number.
 17 | 
 18 | ## Were Cairo VM
 19 | 
 20 | The Cairo VM is currently powering the Starknet blockchain, though its usage is
 21 | not limited to blockchain applications. There are currently five open sources
 22 | implementations of the spec, as defined in the Cairo paper:
 23 | 
 24 | 1. The original Python implementation, deprecated since July 2023
 25 | 2. The Starknet current VM, in rust, from LambdaClass
 26 | 3. A primarily educational Cairo VM in go, also from LambdaClass
 27 | 4. Another go implementation, by Nethermind
 28 | 5. Yet another educational implementation in typescript, by Kakarot
 29 | 6. And here we are, this spreadsheet with its associated app script!
 30 | 
 31 | ## Wy Cairo VM gs
 32 | 
 33 | At the heart of the Cairo VM lies the concept of felt and relocatable. Because
 34 | we are here to keep it simple, say that:
 35 | 
 36 | - a felt (or Field Element) is a constant number between 0 and p (a given prime
 37 |   number), much like (here the cryptographers die) in usual computation a
 38 |   variable is a uint of some kind (uint32 or uint64 in most of the languages and
 39 |   architectures, uint256 in the Ethereum Virtual Machine for example);
 40 | - a relocatable is a reference to a felt or to another relocatable (?). While
 41 |   this sounds complicated, it appears that spreadsheets are by design exactly
 42 |   this, a mix of cells with constant values and cells referencing other cells.
 43 | 
 44 | In the end, the task of the Cairo VM is just to fill some cells such that, at
 45 | each line, the constraints defined by the program holds. For example, one may
 46 | have at a given line an instruction like:
 47 | 
 48 | | Opcode   | dst | src  |
 49 | | -------- | --- | ---- |
 50 | | AssertEq | 10  | =D33 |
 51 | 
 52 | In this context, the run of the Cairo VM would consist in writing in D33 the
 53 | value 10 such that the equality with B33 holds. That's it, you've become a
 54 | cryptographer specialized in ZK.
 55 | 
 56 | ## How Cairo VM gs
 57 | 
 58 | The aim of this implementation is definitely not to reach prod perf (though
 59 | everything is possible in gsheet) but to provide an easy educational,
 60 | plug-and-play tool for running step by step compiled Cairo codes.
 61 | 
 62 | It provides few new functions that can be used directly from the sheet:
 63 | 
 64 | - DECODE_INSTRUCTION(hex): disassemble a Cairo compiled program
 65 | 
 66 | It also adds a menu "Cairo VM" which allows to:
 67 | 
 68 | - load a compiled cairo program
 69 | - run it step by step
 70 | - run it until the end
 71 | 
 72 | ## Wen Cairo VM gs
 73 | 
 74 | This spreadsheet is under active development. Currently, only the
 75 | DECODE_INSTRUCTION is working. Next priorities are to fix the Step and Run menu
 76 | over a small fibonacci program. Then, we will add the option to load any
 77 | compiled program. Eventually, we may stop there or keep improving the VM and
 78 | support Cairo 1.
 79 | 
 80 | ## Contribute
 81 | 
 82 | ### Setup
 83 | 
 84 | To start contributing:
 85 | 
 86 | - fork this repo and `git clone` (as usual)
 87 | - run `npm install` to get the
 88 |   [clasp](https://developers.google.com/apps-script/guides/clasp) CLI tool
 89 | - create a copy of the [main Google sheet](https://cairovm.gs) in the UX
 90 | - clone your app script project locally with the CLI
 91 | 
 92 | ```bash
 93 | npx clasp login
 94 | npx clasp clone <script id> --rootDir .
 95 | ```
 96 | 
 97 | - the script id can be found by:
 98 | 
 99 |   - opening the menu Extensions > Apps Script
100 |   - go to project setting on the left navigation bar
101 |   - copy the ID therein
102 | 
103 | - Cloning the project will double each .ts file into a similar .js file. Delete
104 |   the .js files.
105 | 
106 | The `clasp` CLI is not so convenient and you should take a bit of time to play
107 | around and read the doc. Especially, check that everything is set up correctly
108 | by using
109 | 
110 | ```bash
111 | npx clasp paths
112 | ```
113 | 
114 | and make sure that is shows:
115 | 
116 | ```bash
117 | project <project root>/.clasp.json
118 | ignore <project root>/.claspignore
119 | auth $HOME/.clasprc.json
120 | ```
121 | 
122 | It is recommended to have [`jq`](https://jqlang.github.io/jq/download/)
123 | installed to be able to check the status of the non-ignored files only
124 | 
125 | ```bash
126 | npx clasp status --json | jq ".filesToPush"
127 | ```
128 | 
129 | The `npx clasp push` command has a watch mode that allows you to make sure that
130 | the remote code running on the sheet is always up to date:
131 | 
132 | ```bash
133 | npx clasp push -w
134 | ```
135 | 
136 | ### Using the python venv to compile .cairo files
137 | 
138 | The project uses uv workspaces and cairo-lang to compile .cairo programs:
139 | 
140 | 1. [install uv](https://docs.astral.sh/uv/getting-started/installation/)
141 | 1. run `uv run` to install the required packages and create a venv
142 | 1. you are then ready to compile cairo-program:
143 |    - navigate to the cairo file you want to compile. For instance
144 |      `cd cairo0/fibonacci`
145 |    - then run
146 |      `uv run cairo-compile <FILE TO COMPILE> --ouput main_compiled.json`
147 |    - it's also possible to compile in proof mode using the `--proof-mode`
148 |      parameter, this will generate special identifiers in the artifacts used for
149 |      proof generation:
150 |      `uv run cairo-compile main.cairo --proof_mode --ouput main_compiled.json`
151 | 
152 | The .venv folder created by `uv run` contains the kernel to use for the
153 | notebooks (`.venv/bin/python`).
154 | 
155 | ### Debug
156 | 
157 | The current workflow is like so:
158 | 
159 | - write code in a code editor,
160 | - run `npx clasp push` to push changes to your GAS application (ie your
161 |   spreadsheet),
162 | - test these changes directly on the spreadsheet or in the Extensions>Apps
163 |   Script section (using the execute button to run specific functions to be
164 |   tested)
165 | - repeat the 3 first steps as much as needed
166 | 
167 | You can also run functions locally using `npx clasp run`. Follow
168 | [this documentation](https://github.com/google/clasp/blob/master/docs/run.md) to
169 | set your project:
170 | 
171 | 1. create a GCP project associated with the script in project setting > GCP
172 |    project
173 | 1. add the
174 |    [Apps Script API](https://console.cloud.google.com/marketplace/product/google/script.googleapis.com?q=search)
175 |    to your project
176 | 1. create an OAuth Client ID for a Desktop app
177 |    following[this doc](https://developers.google.com/workspace/guides/create-credentials#oauth-client-id)
178 | 1. download the credentials as `creds.json` and put them at the root of the
179 |    project
180 | 1. `npx clasp login --creds creds.json`
181 | 1. `clasp run`
182 | 


--------------------------------------------------------------------------------
/appsscript.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "timeZone": "Europe/Paris",
 3 |   "dependencies": {},
 4 |   "exceptionLogging": "STACKDRIVER",
 5 |   "runtimeVersion": "V8",
 6 |   "executionApi": {
 7 |     "access": "ANYONE"
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/cairo0/builtins/bitwise_builtin.cairo:
--------------------------------------------------------------------------------
 1 | %builtins bitwise
 2 | 
 3 | from starkware.cairo.common.cairo_builtins import BitwiseBuiltin
 4 | 
 5 | func main{bitwise_ptr: BitwiseBuiltin*}() {
 6 |     assert bitwise_ptr.x = 12;  // Binary 1100
 7 |     assert bitwise_ptr.y = 10;  // Binary 1010
 8 |     assert bitwise_ptr.x_and_y = 8;  // Binary 1000
 9 |     assert bitwise_ptr.x_xor_y = 6;  // Binary 0110
10 |     assert bitwise_ptr.x_or_y = 14;  // Binary 1110
11 | 
12 |     let bitwise_ptr = bitwise_ptr + BitwiseBuiltin.SIZE;
13 | 
14 |     return ();
15 | }
16 | 


--------------------------------------------------------------------------------
/cairo0/builtins/ecop_builtin.cairo:
--------------------------------------------------------------------------------
 1 | %builtins ec_op
 2 | 
 3 | from starkware.cairo.common.cairo_builtins import EcOpBuiltin
 4 | from starkware.cairo.common.ec_point import EcPoint
 5 | 
 6 | func main{ec_op_ptr: EcOpBuiltin*}() {
 7 |     let p = EcPoint(
 8 |         0x6a4beaef5a93425b973179cdba0c9d42f30e01a5f1e2db73da0884b8d6756fc,
 9 |         0x72565ec81bc09ff53fbfad99324a92aa5b39fb58267e395e8abe36290ebf24f,
10 |     );
11 |     let m = 34;
12 |     let q = EcPoint(
13 |         0x654fd7e67a123dd13868093b3b7777f1ffef596c2e324f25ceaf9146698482c,
14 |         0x4fad269cbf860980e38768fe9cb6b0b9ab03ee3fe84cfde2eccce597c874fd8,
15 |     );
16 | 
17 |     assert ec_op_ptr.p = p;
18 |     assert ec_op_ptr.q = q;
19 |     assert ec_op_ptr.m = m;
20 | 
21 |     let r = ec_op_ptr.r;
22 |     let ec_op_ptr = ec_op_ptr + EcOpBuiltin.SIZE;
23 | 
24 |     assert r.x = 108925483682366235368969256555281508851459278989259552980345066351008608800;
25 |     assert r.y = 1592365885972480102953613056006596671718206128324372995731808913669237079419;
26 |     return ();
27 | }
28 | 


--------------------------------------------------------------------------------
/cairo0/builtins/keccak_builtin.cairo:
--------------------------------------------------------------------------------
 1 | %builtins keccak
 2 | 
 3 | from starkware.cairo.common.cairo_builtins import KeccakBuiltin
 4 | from starkware.cairo.common.keccak_state import KeccakBuiltinState
 5 | 
 6 | func main{keccak_ptr: KeccakBuiltin*}() {
 7 |     assert keccak_ptr[0].input = KeccakBuiltinState(1, 2, 3, 4, 5, 6, 7, 8);
 8 |     let result = keccak_ptr[0].output;
 9 |     assert result.s0 = 0x5437ca4807beb9df3871c8467f0c8c2ac42e1f2100e18198f6;
10 |     assert result.s1 = 0x7a753f70755cbbde7882962e5969b2874c2dff11a91716ab31;
11 |     assert result.s2 = 0xe561082c7d6621e7480f773a54870b0dab0ad6151b08ee303a;
12 |     assert result.s3 = 0xb744cd390af9518a46a3d88b6003f7393c7ead3f9a131638be;
13 |     assert result.s4 = 0xf16079da5c848e9f6b99afdf72720169e5209e171f8ef7582e;
14 |     assert result.s5 = 0xe108fbbcea9d86a6d76f01b63c33ffffd896ad8e2b71026060;
15 |     assert result.s6 = 0x9c7aa8a62187936713012ec096925a78b1c1a140ab7a061ca3;
16 |     assert result.s7 = 0xd5774bd1793a6b3940c0a54888a6a3c1e57251a7e727590b40;
17 |     let keccak_ptr = keccak_ptr + KeccakBuiltin.SIZE;
18 |     return ();
19 | }
20 | 


--------------------------------------------------------------------------------
/cairo0/builtins/pedersen_builtin.cairo:
--------------------------------------------------------------------------------
 1 | %builtins pedersen
 2 | 
 3 | from starkware.cairo.common.cairo_builtins import HashBuiltin
 4 | 
 5 | func main{pedersen_ptr: HashBuiltin*}() {
 6 |     assert pedersen_ptr.x = 0;
 7 |     assert pedersen_ptr.y = 0;
 8 |     assert pedersen_ptr.result = 0x49ee3eba8c1600700ee1b87eb599f16716b0b1022947733551fde4050ca6804;
 9 |     let pedersen_ptr = pedersen_ptr + HashBuiltin.SIZE;
10 | 
11 |     assert pedersen_ptr.x = 0;
12 |     assert pedersen_ptr.y = 1;
13 |     assert pedersen_ptr.result = 0x46c9aeb066cc2f41c7124af30514f9e607137fbac950524f5fdace5788f9d43;
14 |     let pedersen_ptr = pedersen_ptr + HashBuiltin.SIZE;
15 | 
16 |     assert pedersen_ptr.x = 1;
17 |     assert pedersen_ptr.y = 0;
18 |     assert pedersen_ptr.result = 0x268a9d47dde48af4b6e2c33932ed1c13adec25555abaa837c376af4ea2f8a94;
19 |     let pedersen_ptr = pedersen_ptr + HashBuiltin.SIZE;
20 | 
21 |     assert pedersen_ptr.x = 54;
22 |     assert pedersen_ptr.y = 1249832432;
23 |     assert pedersen_ptr.result = 0x20120a7d08fd21654c72a9281841406543b16d00faaca1069332053c41c07b8;
24 |     let pedersen_ptr = pedersen_ptr + HashBuiltin.SIZE;
25 | 
26 |     return ();
27 | }
28 | 


--------------------------------------------------------------------------------
/cairo0/builtins/poseidon_builtin.cairo:
--------------------------------------------------------------------------------
 1 | %builtins poseidon
 2 | 
 3 | from starkware.cairo.common.cairo_builtins import PoseidonBuiltin
 4 | from starkware.cairo.common.poseidon_state import PoseidonBuiltinState
 5 | 
 6 | func main{poseidon_ptr: PoseidonBuiltin*}() {
 7 |     assert poseidon_ptr[0].input = PoseidonBuiltinState(1, 2, 3);
 8 |     let result = poseidon_ptr[0].output;
 9 |     let poseidon_ptr = poseidon_ptr + PoseidonBuiltin.SIZE;
10 |     assert result.s0 = 442682200349489646213731521593476982257703159825582578145778919623645026501;
11 |     assert result.s1 = 2233832504250924383748553933071188903279928981104663696710686541536735838182;
12 |     assert result.s2 = 2512222140811166287287541003826449032093371832913959128171347018667852712082;
13 | 
14 |     assert poseidon_ptr[0].input = PoseidonBuiltinState(13, 40, 36);
15 |     let result = poseidon_ptr[0].output;
16 |     let poseidon_ptr = poseidon_ptr + PoseidonBuiltin.SIZE;
17 |     assert result.s0 = 1444012836772460926284672162976355419809540186674760964183552435963176573742;
18 |     assert result.s1 = 1541263763841611133055414279879179440960986686052381666910348740660012074535;
19 |     assert result.s2 = 2502492865904268664943542226035155619416122443735694424675086833952759734985;
20 |     return ();
21 | }
22 | 


--------------------------------------------------------------------------------
/cairo0/builtins/range_check96_builtin.cairo:
--------------------------------------------------------------------------------
1 | %builtins range_check96
2 | 
3 | func main{range_check96_ptr: felt*}() {
4 |     assert [range_check96_ptr] = 2 ** 96 - 1;
5 |     let range_check96_ptr = range_check96_ptr + 1;
6 |     return ();
7 | }
8 | 


--------------------------------------------------------------------------------
/cairo0/builtins/range_check_builtin.cairo:
--------------------------------------------------------------------------------
1 | %builtins range_check
2 | 
3 | func main{range_check_ptr: felt*}() {
4 |     assert [range_check_ptr] = 2 ** 128 - 1;
5 |     let range_check_ptr = range_check_ptr + 1;
6 |     return ();
7 | }
8 | 


--------------------------------------------------------------------------------
/cairo0/dict.cairo:
--------------------------------------------------------------------------------
  1 | from starkware.cairo.common.dict_access import DictAccess
  2 | from starkware.cairo.common.dict import dict_squash, dict_write, dict_read
  3 | from starkware.cairo.common.default_dict import default_dict_new, default_dict_finalize
  4 | from starkware.cairo.common.alloc import alloc
  5 | from starkware.cairo.common.math import unsigned_div_rem
  6 | from starkware.cairo.common.memcpy import memcpy
  7 | from starkware.cairo.common.uint256 import Uint256
  8 | 
  9 | func dict_keys{range_check_ptr}(dict_start: DictAccess*, dict_end: DictAccess*) -> (
 10 |     keys_len: felt, keys: felt*
 11 | ) {
 12 |     alloc_locals;
 13 |     let (local keys_start: felt*) = alloc();
 14 |     let dict_len = dict_end - dict_start;
 15 |     let (local keys_len, _) = unsigned_div_rem(dict_len, DictAccess.SIZE);
 16 |     local range_check_ptr = range_check_ptr;
 17 | 
 18 |     if (dict_len == 0) {
 19 |         return (keys_len, keys_start);
 20 |     }
 21 | 
 22 |     tempvar keys = keys_start;
 23 |     tempvar len = keys_len;
 24 |     tempvar dict = dict_start;
 25 | 
 26 |     loop:
 27 |     let keys = cast([ap - 3], felt*);
 28 |     let len = [ap - 2];
 29 |     let dict = cast([ap - 1], DictAccess*);
 30 | 
 31 |     assert [keys] = dict.key;
 32 |     tempvar keys = keys + 1;
 33 |     tempvar len = len - 1;
 34 |     tempvar dict = dict + DictAccess.SIZE;
 35 | 
 36 |     static_assert keys == [ap - 3];
 37 |     static_assert len == [ap - 2];
 38 |     static_assert dict == [ap - 1];
 39 | 
 40 |     jmp loop if len != 0;
 41 | 
 42 |     return (keys_len, keys_start);
 43 | }
 44 | 
 45 | func dict_values{range_check_ptr}(dict_start: DictAccess*, dict_end: DictAccess*) -> (
 46 |     values_len: felt, values: Uint256*
 47 | ) {
 48 |     alloc_locals;
 49 |     let (local values: Uint256*) = alloc();
 50 |     let dict_len = dict_end - dict_start;
 51 |     let (local values_len, _) = unsigned_div_rem(dict_len, DictAccess.SIZE);
 52 |     local range_check_ptr = range_check_ptr;
 53 | 
 54 |     if (dict_len == 0) {
 55 |         return (values_len, values);
 56 |     }
 57 | 
 58 |     tempvar index = 0;
 59 |     tempvar len = values_len;
 60 |     tempvar dict = dict_start;
 61 | 
 62 |     loop:
 63 |     let index = [ap - 3];
 64 |     let len = [ap - 2];
 65 |     let dict = cast([ap - 1], DictAccess*);
 66 | 
 67 |     let pointer = cast(dict.new_value, Uint256*);
 68 |     assert values[index] = pointer[0];
 69 | 
 70 |     tempvar index = index + 1;
 71 |     tempvar len = len - 1;
 72 |     tempvar dict = dict + DictAccess.SIZE;
 73 | 
 74 |     static_assert index == [ap - 3];
 75 |     static_assert len == [ap - 2];
 76 |     static_assert dict == [ap - 1];
 77 | 
 78 |     jmp loop if len != 0;
 79 | 
 80 |     return (values_len, values);
 81 | }
 82 | 
 83 | func default_dict_copy{range_check_ptr}(start: DictAccess*, end: DictAccess*) -> (
 84 |     DictAccess*, DictAccess*
 85 | ) {
 86 |     alloc_locals;
 87 |     let (squashed_start, squashed_end) = dict_squash(start, end);
 88 |     local range_check_ptr = range_check_ptr;
 89 |     let dict_len = squashed_end - squashed_start;
 90 | 
 91 |     if (dict_len == 0) {
 92 |         tempvar default_value = 0;
 93 |     } else {
 94 |         tempvar default_value = squashed_start.prev_value;
 95 |     }
 96 | 
 97 |     let (local new_start) = default_dict_new(default_value);
 98 |     let new_ptr = new_start;
 99 | 
100 |     if (dict_len == 0) {
101 |         return (new_start, new_ptr);
102 |     }
103 | 
104 |     tempvar squashed_start = squashed_start;
105 |     tempvar dict_len = dict_len;
106 |     tempvar new_ptr = new_ptr;
107 | 
108 |     loop:
109 |     let squashed_start = cast([ap - 3], DictAccess*);
110 |     let dict_len = [ap - 2];
111 |     let new_ptr = cast([ap - 1], DictAccess*);
112 | 
113 |     let key = [squashed_start].key;
114 |     let new_value = [squashed_start].new_value;
115 | 
116 |     dict_write{dict_ptr=new_ptr}(key=key, new_value=new_value);
117 | 
118 |     tempvar squashed_start = squashed_start + DictAccess.SIZE;
119 |     tempvar dict_len = dict_len - DictAccess.SIZE;
120 |     tempvar new_ptr = new_ptr;
121 | 
122 |     static_assert squashed_start == [ap - 3];
123 |     static_assert dict_len == [ap - 2];
124 |     static_assert new_ptr == [ap - 1];
125 | 
126 |     jmp loop if dict_len != 0;
127 | 
128 |     return (new_start, new_ptr);
129 | }
130 | 
131 | namespace Tests {
132 |     namespace DefaultDictCopy {
133 |         func test_should_return_copied_dict{range_check_ptr}() {
134 |             let default_value = 0xdead;
135 |             let (dict_ptr_start) = default_dict_new(default_value);
136 |             let dict_ptr = dict_ptr_start;
137 |             let key = 0x7e1;
138 |             with dict_ptr {
139 |                 let (value) = dict_read(key);
140 |                 assert value = default_value;
141 |                 dict_write(key, 0xff);
142 |                 let (value) = dict_read(key);
143 |                 assert value = 0xff;
144 |                 dict_write(key + 1, 0xff + 1);
145 |                 dict_write(key + 2, 0xff + 2);
146 |                 dict_write(key + 3, 0xff + 3);
147 |                 dict_write(key + 4, 0xff + 4);
148 |             }
149 |             let (new_start, new_ptr) = default_dict_copy(dict_ptr_start, dict_ptr);
150 | 
151 |             assert new_ptr - new_start = DictAccess.SIZE * 5;
152 | 
153 |             let dict_ptr = new_ptr;
154 |             with dict_ptr {
155 |                 let (value) = dict_read(key);
156 |                 assert value = 0xff;
157 |                 let (value) = dict_read(key + 1);
158 |                 assert value = 0xff + 1;
159 |                 let (value) = dict_read(key + 2);
160 |                 assert value = 0xff + 2;
161 |                 let (value) = dict_read(key + 3);
162 |                 assert value = 0xff + 3;
163 |                 let (value) = dict_read(key + 4);
164 |                 assert value = 0xff + 4;
165 |                 let (value) = dict_read(key + 10);
166 |                 assert value = default_value;
167 |             }
168 | 
169 |             return ();
170 |         }
171 | 
172 |         func test_should_copy_empty_dict{range_check_ptr}() {
173 |             alloc_locals;
174 | 
175 |             let (dict_ptr_start) = default_dict_new(0);
176 |             let (new_start, new_ptr) = default_dict_copy(dict_ptr_start, dict_ptr_start);
177 | 
178 |             let key = 0x7e1;
179 |             let dict_ptr = new_ptr;
180 |             with dict_ptr {
181 |                 let (value) = dict_read(key);
182 |                 assert value = 0;
183 |             }
184 |             let (init_dict_start, init_dict_end) = default_dict_finalize(
185 |                 dict_ptr_start, dict_ptr_start, 0
186 |             );
187 |             let (copied_dict_start, copied_dict_end) = default_dict_finalize(
188 |                 new_start, dict_ptr, 0
189 |             );
190 | 
191 |             return ();
192 |         }
193 |     }
194 | 
195 |     namespace DictKeys {
196 |         func test_should_return_keys{range_check_ptr}() {
197 |             alloc_locals;
198 |             let (local dict_start) = default_dict_new(0);
199 |             let dict_ptr = dict_start;
200 | 
201 |             with dict_ptr {
202 |                 dict_write(0xa, 2);
203 |                 dict_write(0xb, 3);
204 |                 dict_write(0xb, 4);
205 |                 dict_read(0xb);
206 |                 dict_write(0xc, 5);
207 |             }
208 | 
209 |             let (keys_len, keys) = dict_keys(dict_start, dict_ptr);
210 | 
211 |             assert keys_len = 5;
212 |             assert [keys + 0] = 0xa;
213 |             assert [keys + 1] = 0xb;
214 |             assert [keys + 2] = 0xb;
215 |             assert [keys + 3] = 0xb;
216 |             assert [keys + 4] = 0xc;
217 | 
218 |             let (squashed_start, squashed_end) = default_dict_finalize(dict_start, dict_ptr, 0);
219 | 
220 |             let (keys_len, keys) = dict_keys(squashed_start, squashed_end);
221 | 
222 |             assert keys_len = 3;
223 |             assert [keys + 0] = 0xa;
224 |             assert [keys + 1] = 0xb;
225 |             assert [keys + 2] = 0xc;
226 | 
227 |             return ();
228 |         }
229 |     }
230 | 
231 |     namespace DictValues {
232 |         func test_should_return_values{range_check_ptr}() {
233 |             alloc_locals;
234 |             let (local dict_start) = default_dict_new(0);
235 |             tempvar value_a = new Uint256(2, 0);
236 |             tempvar value_tmp = new Uint256(3, 0);
237 |             tempvar value_b = new Uint256(4, 0);
238 |             tempvar value_c = new Uint256(5, 0);
239 |             let dict_ptr = dict_start;
240 | 
241 |             with dict_ptr {
242 |                 dict_write(0xa, cast(value_a, felt));
243 |                 dict_write(0xb, cast(value_tmp, felt));
244 |                 dict_write(0xb, cast(value_b, felt));
245 |                 dict_read(0xb);
246 |                 dict_write(0xc, cast(value_c, felt));
247 |             }
248 | 
249 |             let (values_len, values) = dict_values(dict_start, dict_ptr);
250 | 
251 |             assert values_len = 5;
252 |             assert values[0] = value_a[0];
253 |             assert values[1] = value_tmp[0];
254 |             assert values[2] = value_b[0];
255 |             assert values[3] = value_b[0];
256 |             assert values[4] = value_c[0];
257 | 
258 |             let (squashed_start, squashed_end) = default_dict_finalize(dict_start, dict_ptr, 0);
259 | 
260 |             let (values_len, values) = dict_values(squashed_start, squashed_end);
261 | 
262 |             assert values_len = 3;
263 |             assert values[0] = value_a[0];
264 |             assert values[1] = value_b[0];
265 |             assert values[2] = value_c[0];
266 | 
267 |             return ();
268 |         }
269 |     }
270 | }


--------------------------------------------------------------------------------
/cairo0/fibonacci/fibonacci.cairo:
--------------------------------------------------------------------------------
 1 | func fibonacci(n: felt) -> felt {
 2 |     tempvar n = n - 2;
 3 |     tempvar i = 1;
 4 |     tempvar j = 1;
 5 | 
 6 |     body:
 7 |     let n = [ap - 3];
 8 |     let i = [ap - 2];
 9 |     let j = [ap - 1];
10 |     let next = i + j;
11 | 
12 |     tempvar n = n - 1;
13 |     tempvar i = j;
14 |     tempvar j = next;
15 | 
16 |     static_assert n == [ap - 3];
17 |     static_assert i == [ap - 2];
18 |     static_assert j == [ap - 1];
19 | 
20 |     jmp body if n != 0;
21 | 
22 |     end:
23 |     let n = [ap - 3];
24 |     let i = [ap - 2];
25 |     let j = [ap - 1];
26 | 
27 |     return j;
28 | }


--------------------------------------------------------------------------------
/cairo0/fibonacci/main.cairo:
--------------------------------------------------------------------------------
1 | from fibonacci import fibonacci
2 | 
3 | func main() {
4 |     fibonacci(4);
5 |     return ();
6 | }
7 | 


--------------------------------------------------------------------------------
/cairo0/main.cairo:
--------------------------------------------------------------------------------
 1 | %builtins pedersen range_check bitwise
 2 | 
 3 | from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin
 4 | 
 5 | func main{pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() {
 6 |     tempvar res = 1234;
 7 |     assert [range_check_ptr] = res;
 8 |     let range_check_ptr = range_check_ptr + 1;
 9 | 
10 |     let mask = 0x10;
11 |     assert bitwise_ptr.x = res;
12 |     assert bitwise_ptr.y = mask;
13 |     tempvar x_and_y = bitwise_ptr.x_and_y;
14 |     tempvar x_xor_y = bitwise_ptr.x_xor_y;
15 |     tempvar x_or_y = bitwise_ptr.x_or_y;
16 |     let bitwise_ptr = bitwise_ptr + BitwiseBuiltin.SIZE;
17 | 
18 |     assert pedersen_ptr.x = res;
19 |     assert pedersen_ptr.y = mask;
20 |     tempvar hash = pedersen_ptr.result;
21 |     let pedersen_ptr = pedersen_ptr + HashBuiltin.SIZE;
22 | 
23 |     return ();
24 | }
25 | 


--------------------------------------------------------------------------------
/cairo0/main_memory.bin:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ClementWalter/cairo-vm-df/d18ee69e9ef9a194a3cb6984968199c280eceb3c/cairo0/main_memory.bin


--------------------------------------------------------------------------------
/cairo0/main_trace.bin:
--------------------------------------------------------------------------------
1 | 
	 
2 | !!""#$%&


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "cairo-vm-gs",
 3 |   "version": "0.0.1",
 4 |   "description": "A Google app script Cairo VM implementation",
 5 |   "main": "",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "author": "Clément Walter <clement0walter@gmail.com>",
10 |   "license": "ISC",
11 |   "dependencies": {
12 |     "@google/clasp": "^2.4.2",
13 |     "@types/google-apps-script": "^1.0.82"
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [project]
 2 | authors = [
 3 |   { name = "Clément Walter", email = "clement0walter@gmail.com" },
 4 |   { name = "Antoine Fondeur" },
 5 | ]
 6 | requires-python = "~=3.9.0"
 7 | dependencies = ["cairo-lang<1.0.0,>=0.13.1", "polars>=1.22.0"]
 8 | name = "cairo-vm-gs"
 9 | version = "0.1.0"
10 | description = ""
11 | 
12 | 
13 | [tool.pdm.build]
14 | includes = []
15 | 
16 | [build-system]
17 | requires = ["pdm-backend"]
18 | build-backend = "pdm.backend"
19 | 
20 | [dependency-groups]
21 | dev = [
22 |     "jupyter>=1.1.1",
23 | ]
24 | 


--------------------------------------------------------------------------------
/src/builtins/bitwise/bitwise.ts:
--------------------------------------------------------------------------------
 1 | // calculates bitwise 'AND' of given two inputs x and y
 2 | function bitwiseAnd(x: bigint, y: bigint): bigint {
 3 |   return x & y;
 4 | }
 5 | 
 6 | // calculates bitwise 'OR' of given two inputs x and y
 7 | function bitwiseOr(x: bigint, y: bigint): bigint {
 8 |   return x | y;
 9 | }
10 | 
11 | // calculates bitwise 'XOR' of given two inputs x and y
12 | function bitwiseXor(x: bigint, y: bigint): bigint {
13 |   return x ^ y;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/builtins/ec_op/ec_op.ts:
--------------------------------------------------------------------------------
 1 | function ecAdd(p: AffinePoint, q: AffinePoint): AffinePoint {
 2 |   var r = new AffinePoint("0x0", "0x0");
 3 |   //Deal with neutral elements
 4 |   if (p.isNeutralElement) {
 5 |     return q;
 6 |   } else if (q.isNeutralElement) {
 7 |     return p;
 8 |   }
 9 | 
10 |   //Deal with case where p is the inverse of q
11 |   if (p.x === q.x && p.y === -q.y) {
12 |     r.isNeutralElement = true;
13 |     return r;
14 |   }
15 | 
16 |   //Tangent Rule
17 |   if (p.x === q.x && p.y === q.y && p.y !== BigInt(0)) {
18 |     var slope: bigint = modMul(
19 |       modAdd(modMul(modMul(BigInt(3), p.x), p.x), ALPHA),
20 |       modInv(modMul(BigInt(2), p.y)),
21 |     );
22 |     r.x = modSub(modSub(modMul(slope, slope), p.x), p.x);
23 |     r.y = modSub(modMul(slope, modSub(p.x, r.x)), p.y);
24 |     return r;
25 |   }
26 | 
27 |   //Chord Rule
28 |   if (p.x !== q.x) {
29 |     var slope: bigint = modMul(modSub(p.y, q.y), modInv(modSub(p.x, q.x)));
30 |     r.x = modSub(modSub(modMul(slope, slope), p.x), q.x);
31 |     r.y = modSub(modMul(slope, modSub(p.x, r.x)), p.y);
32 |     return r;
33 |   }
34 | }
35 | 
36 | function ecMul(m: bigint, p: AffinePoint): AffinePoint {
37 |   var mBool: boolean[] = toBitsLe(m);
38 |   var numOfBits: number = mBool.length;
39 |   var points: AffinePoint[] = [p];
40 |   var res = new AffinePoint("0x0", "0x0", true);
41 | 
42 |   for (let i = 1; i < numOfBits; i++) {
43 |     points.push(ecAdd(points[points.length - 1], points[points.length - 1]));
44 |   }
45 |   for (let i = 0; i < numOfBits; i++) {
46 |     if (mBool[i]) {
47 |       res = ecAdd(res, points[i]);
48 |     }
49 |   }
50 |   return res;
51 | }
52 | 
53 | function ecOp(m: bigint, p: AffinePoint, q: AffinePoint): AffinePoint {
54 |   return ecAdd(p, ecMul(m, q));
55 | }
56 | 


--------------------------------------------------------------------------------
/src/builtins/ec_op/modular_ar.ts:
--------------------------------------------------------------------------------
 1 | function modAdd(a: bigint, b: bigint, p: bigint = PRIME): bigint {
 2 |   var result: bigint = (a + b) % p;
 3 |   return result < 0 ? result + p : result;
 4 | }
 5 | 
 6 | function modSub(a: bigint, b: bigint, p: bigint = PRIME): bigint {
 7 |   var result: bigint = (a - b) % p;
 8 |   return result < 0 ? result + p : result;
 9 | }
10 | 
11 | function modMul(a: bigint, b: bigint, p: bigint = PRIME): bigint {
12 |   var result: bigint = (a * b) % p;
13 |   return result < 0 ? result + p : result;
14 | }
15 | 
16 | function modPow(a: bigint, pow: number): bigint {
17 |   var result: bigint = a;
18 |   for (var i = 1; i < pow; i++) {
19 |     result = modMul(BigInt(result), a);
20 |   }
21 |   return result;
22 | }
23 | 
24 | function modInv(a: bigint, p: bigint = PRIME): bigint {
25 |   return modExp(a, p - BigInt(2), p);
26 | }
27 | 
28 | function modExp(base: bigint, exponent: bigint, p: bigint = PRIME): bigint {
29 |   var result = BigInt(1);
30 |   base = base % p;
31 | 
32 |   while (exponent > 0) {
33 |     if (exponent % BigInt(2) === BigInt(1)) {
34 |       result = (result * base) % p;
35 |     }
36 |     exponent = exponent >> BigInt(1);
37 |     base = (base * base) % p;
38 |   }
39 | 
40 |   return result;
41 | }
42 | 


--------------------------------------------------------------------------------
/src/builtins/ecdsa/ecdsa.ts:
--------------------------------------------------------------------------------
 1 | function signMessage(message: bigint, privateKey: bigint): SignatureType {
 2 |   var k: bigint = getRandomBigInt(ORDER - BigInt(1)) + BigInt(1);
 3 |   var rPoint: AffinePoint = ecMul(k, GENERATOR);
 4 |   var r: bigint = rPoint.x % ORDER;
 5 |   if (r === BigInt(0)) {
 6 |     return signMessage(message, privateKey);
 7 |   }
 8 |   var s: bigint = modMul(
 9 |     modInv(k, ORDER),
10 |     modAdd(message, modMul(r, privateKey, ORDER), ORDER),
11 |     ORDER,
12 |   );
13 |   return { r: r, s: s } as SignatureType;
14 | }
15 | 
16 | function verifySignature(
17 |   signature: SignatureType,
18 |   message: bigint,
19 |   publicKey: AffinePoint,
20 | ) {
21 |   var sInv: bigint = modInv(signature.s, ORDER);
22 |   var u: bigint = modMul(message, sInv, ORDER);
23 |   var v: bigint = modMul(signature.r, sInv, ORDER);
24 |   var c: AffinePoint = ecAdd(ecMul(u, GENERATOR), ecMul(v, publicKey));
25 |   return c.x === signature.r;
26 | }
27 | 
28 | function getRandomBigInt(n: bigint): bigint {
29 |   //NOT a cryptographically secure PRNG
30 |   var hexDigitsPRIME: number = PRIME.toString(16).length;
31 |   var s = "0x";
32 |   var r = "0123456789abcdef";
33 |   for (var i = 0; i < hexDigitsPRIME; i++) {
34 |     s += r.charAt(Math.floor(Math.random() * r.length));
35 |   }
36 |   return BigInt(s) % n;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/builtins/keccak/keccak_f1600.ts:
--------------------------------------------------------------------------------
  1 | // Keccak implementation from https://github.com/paulmillr/noble-hashes
  2 | 
  3 | const U32_MASK64 = BigInt(2 ** 32 - 1);
  4 | const _32n = BigInt(32);
  5 | 
  6 | function fromBig(n: bigint, le = false) {
  7 |   if (le)
  8 |     return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
  9 |   return {
 10 |     h: Number((n >> _32n) & U32_MASK64) | 0,
 11 |     l: Number(n & U32_MASK64) | 0,
 12 |   };
 13 | }
 14 | 
 15 | function split(lst: bigint[], le = false) {
 16 |   let Ah = new Uint32Array(lst.length);
 17 |   let Al = new Uint32Array(lst.length);
 18 |   for (let i = 0; i < lst.length; i++) {
 19 |     const { h, l } = fromBig(lst[i], le);
 20 |     [Ah[i], Al[i]] = [h, l];
 21 |   }
 22 |   return [Ah, Al];
 23 | }
 24 | 
 25 | // Left rotate for Shift in [1, 32)
 26 | const rotlSH = (h: number, l: number, s: number) => (h << s) | (l >>> (32 - s));
 27 | const rotlSL = (h: number, l: number, s: number) => (l << s) | (h >>> (32 - s));
 28 | // Left rotate for Shift in (32, 64), NOTE: 32 is special case.
 29 | const rotlBH = (h: number, l: number, s: number) =>
 30 |   (l << (s - 32)) | (h >>> (64 - s));
 31 | const rotlBL = (h: number, l: number, s: number) =>
 32 |   (h << (s - 32)) | (l >>> (64 - s));
 33 | 
 34 | // Various per round constants calculations
 35 | const SHA3_PI: number[] = [];
 36 | const SHA3_ROTL: number[] = [];
 37 | const _SHA3_IOTA: bigint[] = [];
 38 | const _0n = BigInt(0);
 39 | const _1n = BigInt(1);
 40 | const _2n = BigInt(2);
 41 | const _7n = BigInt(7);
 42 | const _256n = BigInt(256);
 43 | const _0x71n = BigInt(0x71);
 44 | for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
 45 |   // Pi
 46 |   [x, y] = [y, (2 * x + 3 * y) % 5];
 47 |   SHA3_PI.push(2 * (5 * y + x));
 48 |   // Rotational
 49 |   SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
 50 |   // Iota
 51 |   let t = _0n;
 52 |   for (let j = 0; j < 7; j++) {
 53 |     R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
 54 |     if (R & _2n) t ^= _1n << ((_1n << BigInt(j)) - _1n);
 55 |   }
 56 |   _SHA3_IOTA.push(t);
 57 | }
 58 | const [SHA3_IOTA_H, SHA3_IOTA_L] = split(_SHA3_IOTA, true);
 59 | 
 60 | // Left rotation (without 0, 32, 64)
 61 | const rotlH = (h: number, l: number, s: number) =>
 62 |   s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
 63 | const rotlL = (h: number, l: number, s: number) =>
 64 |   s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
 65 | 
 66 | // Same as keccakf1600, but allows to skip some rounds
 67 | function keccakP(s: Uint32Array, rounds: number = 24) {
 68 |   const B = new Uint32Array(5 * 2);
 69 |   // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
 70 |   for (let round = 24 - rounds; round < 24; round++) {
 71 |     // Theta θ
 72 |     for (let x = 0; x < 10; x++)
 73 |       B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
 74 |     for (let x = 0; x < 10; x += 2) {
 75 |       const idx1 = (x + 8) % 10;
 76 |       const idx0 = (x + 2) % 10;
 77 |       const B0 = B[idx0];
 78 |       const B1 = B[idx0 + 1];
 79 |       const Th = rotlH(B0, B1, 1) ^ B[idx1];
 80 |       const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
 81 |       for (let y = 0; y < 50; y += 10) {
 82 |         s[x + y] ^= Th;
 83 |         s[x + y + 1] ^= Tl;
 84 |       }
 85 |     }
 86 |     // Rho (ρ) and Pi (π)
 87 |     let curH = s[2];
 88 |     let curL = s[3];
 89 |     for (let t = 0; t < 24; t++) {
 90 |       const shift = SHA3_ROTL[t];
 91 |       const Th = rotlH(curH, curL, shift);
 92 |       const Tl = rotlL(curH, curL, shift);
 93 |       const PI = SHA3_PI[t];
 94 |       curH = s[PI];
 95 |       curL = s[PI + 1];
 96 |       s[PI] = Th;
 97 |       s[PI + 1] = Tl;
 98 |     }
 99 |     // Chi (χ)
100 |     for (let y = 0; y < 50; y += 10) {
101 |       for (let x = 0; x < 10; x++) B[x] = s[y + x];
102 |       for (let x = 0; x < 10; x++)
103 |         s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
104 |     }
105 |     // Iota (ι)
106 |     s[0] ^= SHA3_IOTA_H[round];
107 |     s[1] ^= SHA3_IOTA_L[round];
108 |   }
109 |   B.fill(0);
110 | }
111 | 


--------------------------------------------------------------------------------
/src/builtins/keccak/keccak_utils.ts:
--------------------------------------------------------------------------------
 1 | // Utils for keccak come from paulmillr's repo :
 2 | // https://github.com/paulmillr/noble-curves and https://github.com/paulmillr/noble-hashes
 3 | 
 4 | type TypedArray =
 5 |   | Int8Array
 6 |   | Uint8ClampedArray
 7 |   | Uint8Array
 8 |   | Uint16Array
 9 |   | Int16Array
10 |   | Uint32Array
11 |   | Int32Array;
12 | const u8 = (arr: TypedArray) =>
13 |   new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
14 | const u32 = (arr: TypedArray) =>
15 |   new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
16 | 
17 | function concatBytes(...arrays: Uint8Array[]): Uint8Array {
18 |   let sum = 0;
19 |   for (let i = 0; i < arrays.length; i++) {
20 |     const a = arrays[i];
21 |     sum += a.length;
22 |   }
23 |   const res = new Uint8Array(sum);
24 |   for (let i = 0, pad = 0; i < arrays.length; i++) {
25 |     const a = arrays[i];
26 |     res.set(a, pad);
27 |     pad += a.length;
28 |   }
29 |   return res;
30 | }
31 | 
32 | const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;
33 | function asciiToBase16(ch: number): number | undefined {
34 |   if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48
35 |   if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)
36 |   if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)
37 |   return;
38 | }
39 | 
40 | const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>
41 |   i.toString(16).padStart(2, "0"),
42 | );
43 | function bytesToHex(bytes: Uint8Array): string {
44 |   // pre-caching improves the speed 6x
45 |   let hex = "";
46 |   for (let i = 0; i < bytes.length; i++) {
47 |     hex += hexes[bytes[i]];
48 |   }
49 |   return hex;
50 | }
51 | 
52 | function hexToBytes(hex: string): Uint8Array {
53 |   if (typeof hex !== "string")
54 |     throw new Error("hex string expected, got " + typeof hex);
55 |   const hl = hex.length;
56 |   const al = hl / 2;
57 |   if (hl % 2)
58 |     throw new Error("hex string expected, got unpadded hex of length " + hl);
59 |   const array = new Uint8Array(al);
60 |   for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
61 |     const n1 = asciiToBase16(hex.charCodeAt(hi));
62 |     const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
63 |     if (n1 === undefined || n2 === undefined) {
64 |       const char = hex[hi] + hex[hi + 1];
65 |       throw new Error(
66 |         'hex string expected, got non-hex character "' +
67 |           char +
68 |           '" at index ' +
69 |           hi,
70 |       );
71 |     }
72 |     array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
73 |   }
74 |   return array;
75 | }
76 | 
77 | function hexToNumber(hex: string): bigint {
78 |   return hex === "" ? _0n : BigInt("0x" + hex); // Big Endian
79 | }
80 | 
81 | function bytesToNumberLE(bytes: Uint8Array): bigint {
82 |   return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
83 | }
84 | function numberToBytesBE(n: number | bigint, len: number): Uint8Array {
85 |   return hexToBytes(n.toString(16).padStart(len * 2, "0"));
86 | }
87 | function numberToBytesLE(n: number | bigint, len: number): Uint8Array {
88 |   return numberToBytesBE(n, len).reverse();
89 | }
90 | 


--------------------------------------------------------------------------------
/src/builtins/pedersen/pedersen.ts:
--------------------------------------------------------------------------------
 1 | //The hash function implementation comes from the rust one of Lambdawork:
 2 | //https://github.com/lambdaclass/lambdaworks/blob/main/crypto/src/hash/pedersen/mod.rs#L43
 3 | 
 4 | function pedersen(x: bigint, y: bigint): bigint {
 5 |   var xBool: boolean[] = toBitsLe(x);
 6 |   var yBool: boolean[] = toBitsLe(y);
 7 |   var hash: AffinePoint = SHIFT_POINT;
 8 | 
 9 |   hash = lookupAndAccumulate(hash, xBool.slice(0, 248), P1);
10 |   hash = lookupAndAccumulate(hash, xBool.slice(248, 252), P2);
11 |   hash = lookupAndAccumulate(hash, yBool.slice(0, 248), P3);
12 |   hash = lookupAndAccumulate(hash, yBool.slice(248, 252), P4);
13 | 
14 |   return hash.x;
15 | }
16 | 
17 | function lookupAndAccumulate(
18 |   res: AffinePoint,
19 |   bits: boolean[],
20 |   prep: AffinePoint[],
21 | ): AffinePoint {
22 |   var chunksOfBit: boolean[][] = chunks(bits, CURVE_CONST_BITS);
23 |   chunksOfBit.forEach((v, i) => {
24 |     var offset = boolsToUsizeLe(v);
25 |     if (offset > 0) {
26 |       res = ecAdd(res, prep[i * TABLE_SIZE + offset - 1]);
27 |     }
28 |   });
29 |   return res;
30 | }
31 | 
32 | function boolsToUsizeLe(bools: boolean[]): number {
33 |   var result: number = 0;
34 |   for (const [ind, bit] of bools.entries()) {
35 |     if (bit) {
36 |       result += 1 << ind;
37 |     }
38 |   }
39 |   return result;
40 | }
41 | 
42 | function chunks(bits: boolean[], sizeOfChunk: number): boolean[][] {
43 |   const chunksOfBit: boolean[][] = [];
44 |   for (let i = 0; i < bits.length; i += sizeOfChunk) {
45 |     const chunk = bits.slice(i, i + sizeOfChunk);
46 |     chunksOfBit.push(chunk);
47 |   }
48 |   return chunksOfBit;
49 | }
50 | 
51 | function toBitsLe(x: bigint): boolean[] {
52 |   let binaryString = x.toString(2);
53 |   const bits = binaryString.split("").map((bit) => bit === "1");
54 |   bits.reverse();
55 |   return bits;
56 | }
57 | 


--------------------------------------------------------------------------------
/src/builtins/poseidon/constants.ts:
--------------------------------------------------------------------------------
   1 | const matrix: bigint[][] = [
   2 |   [BigInt(3), BigInt(1), BigInt(1)],
   3 |   [BigInt(1), BigInt(-1), BigInt(1)],
   4 |   [BigInt(1), BigInt(1), BigInt(-2)],
   5 | ];
   6 | 
   7 | const roundKeys: bigint[][] = [
   8 |   [
   9 |     BigInt(
  10 |       "2950795762459345168613727575620414179244544320470208355568817838579231751791",
  11 |     ),
  12 |     BigInt(
  13 |       "1587446564224215276866294500450702039420286416111469274423465069420553242820",
  14 |     ),
  15 |     BigInt(
  16 |       "1645965921169490687904413452218868659025437693527479459426157555728339600137",
  17 |     ),
  18 |   ],
  19 |   [
  20 |     BigInt(
  21 |       "2782373324549879794752287702905278018819686065818504085638398966973694145741",
  22 |     ),
  23 |     BigInt(
  24 |       "3409172630025222641379726933524480516420204828329395644967085131392375707302",
  25 |     ),
  26 |     BigInt(
  27 |       "2379053116496905638239090788901387719228422033660130943198035907032739387135",
  28 |     ),
  29 |   ],
  30 |   [
  31 |     BigInt(
  32 |       "2570819397480941104144008784293466051718826502582588529995520356691856497111",
  33 |     ),
  34 |     BigInt(
  35 |       "3546220846133880637977653625763703334841539452343273304410918449202580719746",
  36 |     ),
  37 |     BigInt(
  38 |       "2720682389492889709700489490056111332164748138023159726590726667539759963454",
  39 |     ),
  40 |   ],
  41 |   [
  42 |     BigInt(
  43 |       "1899653471897224903834726250400246354200311275092866725547887381599836519005",
  44 |     ),
  45 |     BigInt(
  46 |       "2369443697923857319844855392163763375394720104106200469525915896159690979559",
  47 |     ),
  48 |     BigInt(
  49 |       "2354174693689535854311272135513626412848402744119855553970180659094265527996",
  50 |     ),
  51 |   ],
  52 |   [
  53 |     BigInt(
  54 |       "2404084503073127963385083467393598147276436640877011103379112521338973185443",
  55 |     ),
  56 |     BigInt(
  57 |       "950320777137731763811524327595514151340412860090489448295239456547370725376",
  58 |     ),
  59 |     BigInt(
  60 |       "2121140748740143694053732746913428481442990369183417228688865837805149503386",
  61 |     ),
  62 |   ],
  63 |   [
  64 |     BigInt(
  65 |       "2372065044800422557577242066480215868569521938346032514014152523102053709709",
  66 |     ),
  67 |     BigInt(
  68 |       "2618497439310693947058545060953893433487994458443568169824149550389484489896",
  69 |     ),
  70 |     BigInt(
  71 |       "3518297267402065742048564133910509847197496119850246255805075095266319996916",
  72 |     ),
  73 |   ],
  74 |   [
  75 |     BigInt(
  76 |       "340529752683340505065238931581518232901634742162506851191464448040657139775",
  77 |     ),
  78 |     BigInt(
  79 |       "1954876811294863748406056845662382214841467408616109501720437541211031966538",
  80 |     ),
  81 |     BigInt(
  82 |       "813813157354633930267029888722341725864333883175521358739311868164460385261",
  83 |     ),
  84 |   ],
  85 |   [
  86 |     BigInt(
  87 |       "71901595776070443337150458310956362034911936706490730914901986556638720031",
  88 |     ),
  89 |     BigInt(
  90 |       "2789761472166115462625363403490399263810962093264318361008954888847594113421",
  91 |     ),
  92 |     BigInt(
  93 |       "2628791615374802560074754031104384456692791616314774034906110098358135152410",
  94 |     ),
  95 |   ],
  96 |   [
  97 |     BigInt(
  98 |       "3617032588734559635167557152518265808024917503198278888820567553943986939719",
  99 |     ),
 100 |     BigInt(
 101 |       "2624012360209966117322788103333497793082705816015202046036057821340914061980",
 102 |     ),
 103 |     BigInt(
 104 |       "149101987103211771991327927827692640556911620408176100290586418839323044234",
 105 |     ),
 106 |   ],
 107 |   [
 108 |     BigInt(
 109 |       "1039927963829140138166373450440320262590862908847727961488297105916489431045",
 110 |     ),
 111 |     BigInt(
 112 |       "2213946951050724449162431068646025833746639391992751674082854766704900195669",
 113 |     ),
 114 |     BigInt(
 115 |       "2792724903541814965769131737117981991997031078369482697195201969174353468597",
 116 |     ),
 117 |   ],
 118 |   [
 119 |     BigInt(
 120 |       "3212031629728871219804596347439383805499808476303618848198208101593976279441",
 121 |     ),
 122 |     BigInt(
 123 |       "3343514080098703935339621028041191631325798327656683100151836206557453199613",
 124 |     ),
 125 |     BigInt(
 126 |       "614054702436541219556958850933730254992710988573177298270089989048553060199",
 127 |     ),
 128 |   ],
 129 |   [
 130 |     BigInt(
 131 |       "148148081026449726283933484730968827750202042869875329032965774667206931170",
 132 |     ),
 133 |     BigInt(
 134 |       "1158283532103191908366672518396366136968613180867652172211392033571980848414",
 135 |     ),
 136 |     BigInt(
 137 |       "1032400527342371389481069504520755916075559110755235773196747439146396688513",
 138 |     ),
 139 |   ],
 140 |   [
 141 |     BigInt(
 142 |       "806900704622005851310078578853499250941978435851598088619290797134710613736",
 143 |     ),
 144 |     BigInt(
 145 |       "462498083559902778091095573017508352472262817904991134671058825705968404510",
 146 |     ),
 147 |     BigInt(
 148 |       "1003580119810278869589347418043095667699674425582646347949349245557449452503",
 149 |     ),
 150 |   ],
 151 |   [
 152 |     BigInt(
 153 |       "619074932220101074089137133998298830285661916867732916607601635248249357793",
 154 |     ),
 155 |     BigInt(
 156 |       "2635090520059500019661864086615522409798872905401305311748231832709078452746",
 157 |     ),
 158 |     BigInt(
 159 |       "978252636251682252755279071140187792306115352460774007308726210405257135181",
 160 |     ),
 161 |   ],
 162 |   [
 163 |     BigInt(
 164 |       "1766912167973123409669091967764158892111310474906691336473559256218048677083",
 165 |     ),
 166 |     BigInt(
 167 |       "1663265127259512472182980890707014969235283233442916350121860684522654120381",
 168 |     ),
 169 |     BigInt(
 170 |       "3532407621206959585000336211742670185380751515636605428496206887841428074250",
 171 |     ),
 172 |   ],
 173 |   [
 174 |     BigInt(
 175 |       "2507023127157093845256722098502856938353143387711652912931112668310034975446",
 176 |     ),
 177 |     BigInt(
 178 |       "3321152907858462102434883844787153373036767230808678981306827073335525034593",
 179 |     ),
 180 |     BigInt(
 181 |       "3039253036806065280643845548147711477270022154459620569428286684179698125661",
 182 |     ),
 183 |   ],
 184 |   [
 185 |     BigInt(
 186 |       "103480338868480851881924519768416587261556021758163719199282794248762465380",
 187 |     ),
 188 |     BigInt(
 189 |       "2394049781357087698434751577708655768465803975478348134669006211289636928495",
 190 |     ),
 191 |     BigInt(
 192 |       "2660531560345476340796109810821127229446538730404600368347902087220064379579",
 193 |     ),
 194 |   ],
 195 |   [
 196 |     BigInt(
 197 |       "3603166934034556203649050570865466556260359798872408576857928196141785055563",
 198 |     ),
 199 |     BigInt(
 200 |       "1553799760191949768532188139643704561532896296986025007089826672890485412324",
 201 |     ),
 202 |     BigInt(
 203 |       "2744284717053657689091306578463476341218866418732695211367062598446038965164",
 204 |     ),
 205 |   ],
 206 |   [
 207 |     BigInt(
 208 |       "320745764922149897598257794663594419839885234101078803811049904310835548856",
 209 |     ),
 210 |     BigInt(
 211 |       "979382242100682161589753881721708883681034024104145498709287731138044566302",
 212 |     ),
 213 |     BigInt(
 214 |       "1860426855810549882740147175136418997351054138609396651615467358416651354991",
 215 |     ),
 216 |   ],
 217 |   [
 218 |     BigInt(
 219 |       "336173081054369235994909356892506146234495707857220254489443629387613956145",
 220 |     ),
 221 |     BigInt(
 222 |       "1632470326779699229772327605759783482411227247311431865655466227711078175883",
 223 |     ),
 224 |     BigInt(
 225 |       "921958250077481394074960433988881176409497663777043304881055317463712938502",
 226 |     ),
 227 |   ],
 228 |   [
 229 |     BigInt(
 230 |       "3034358982193370602048539901033542101022185309652879937418114324899281842797",
 231 |     ),
 232 |     BigInt(
 233 |       "25626282149517463867572353922222474817434101087272320606729439087234878607",
 234 |     ),
 235 |     BigInt(
 236 |       "3002662261401575565838149305485737102400501329139562227180277188790091853682",
 237 |     ),
 238 |   ],
 239 |   [
 240 |     BigInt(
 241 |       "2939684373453383817196521641512509179310654199629514917426341354023324109367",
 242 |     ),
 243 |     BigInt(
 244 |       "1076484609897998179434851570277297233169621096172424141759873688902355505136",
 245 |     ),
 246 |     BigInt(
 247 |       "2575095284833160494841112025725243274091830284746697961080467506739203605049",
 248 |     ),
 249 |   ],
 250 |   [
 251 |     BigInt(
 252 |       "3565075264617591783581665711620369529657840830498005563542124551465195621851",
 253 |     ),
 254 |     BigInt(
 255 |       "2197016502533303822395077038351174326125210255869204501838837289716363437993",
 256 |     ),
 257 |     BigInt(
 258 |       "331415322883530754594261416546036195982886300052707474899691116664327869405",
 259 |     ),
 260 |   ],
 261 |   [
 262 |     BigInt(
 263 |       "1935011233711290003793244296594669823169522055520303479680359990463281661839",
 264 |     ),
 265 |     BigInt(
 266 |       "3495901467168087413996941216661589517270845976538454329511167073314577412322",
 267 |     ),
 268 |     BigInt(
 269 |       "954195417117133246453562983448451025087661597543338750600301835944144520375",
 270 |     ),
 271 |   ],
 272 |   [
 273 |     BigInt(
 274 |       "1271840477709992894995746871435810599280944810893784031132923384456797925777",
 275 |     ),
 276 |     BigInt(
 277 |       "2565310762274337662754531859505158700827688964841878141121196528015826671847",
 278 |     ),
 279 |     BigInt(
 280 |       "3365022288251637014588279139038152521653896670895105540140002607272936852513",
 281 |     ),
 282 |   ],
 283 |   [
 284 |     BigInt(
 285 |       "1660592021628965529963974299647026602622092163312666588591285654477111176051",
 286 |     ),
 287 |     BigInt(
 288 |       "970104372286014048279296575474974982288801187216974504035759997141059513421",
 289 |     ),
 290 |     BigInt(
 291 |       "2617024574317953753849168721871770134225690844968986289121504184985993971227",
 292 |     ),
 293 |   ],
 294 |   [
 295 |     BigInt(
 296 |       "999899815343607746071464113462778273556695659506865124478430189024755832262",
 297 |     ),
 298 |     BigInt(
 299 |       "2228536129413411161615629030408828764980855956560026807518714080003644769896",
 300 |     ),
 301 |     BigInt(
 302 |       "2701953891198001564547196795777701119629537795442025393867364730330476403227",
 303 |     ),
 304 |   ],
 305 |   [
 306 |     BigInt(
 307 |       "837078355588159388741598313782044128527494922918203556465116291436461597853",
 308 |     ),
 309 |     BigInt(
 310 |       "2121749601840466143704862369657561429793951309962582099604848281796392359214",
 311 |     ),
 312 |     BigInt(
 313 |       "771812260179247428733132708063116523892339056677915387749121983038690154755",
 314 |     ),
 315 |   ],
 316 |   [
 317 |     BigInt(
 318 |       "3317336423132806446086732225036532603224267214833263122557471741829060578219",
 319 |     ),
 320 |     BigInt(
 321 |       "481570067997721834712647566896657604857788523050900222145547508314620762046",
 322 |     ),
 323 |     BigInt(
 324 |       "242195042559343964206291740270858862066153636168162642380846129622127460192",
 325 |     ),
 326 |   ],
 327 |   [
 328 |     BigInt(
 329 |       "2855462178889999218204481481614105202770810647859867354506557827319138379686",
 330 |     ),
 331 |     BigInt(
 332 |       "3525521107148375040131784770413887305850308357895464453970651672160034885202",
 333 |     ),
 334 |     BigInt(
 335 |       "1320839531502392535964065058804908871811967681250362364246430459003920305799",
 336 |     ),
 337 |   ],
 338 |   [
 339 |     BigInt(
 340 |       "2514191518588387125173345107242226637171897291221681115249521904869763202419",
 341 |     ),
 342 |     BigInt(
 343 |       "2798335750958827619666318316247381695117827718387653874070218127140615157902",
 344 |     ),
 345 |     BigInt(
 346 |       "2808467767967035643407948058486565877867906577474361783201337540214875566395",
 347 |     ),
 348 |   ],
 349 |   [
 350 |     BigInt(
 351 |       "3551834385992706206273955480294669176699286104229279436819137165202231595747",
 352 |     ),
 353 |     BigInt(
 354 |       "1219439673853113792340300173186247996249367102884530407862469123523013083971",
 355 |     ),
 356 |     BigInt(
 357 |       "761519904537984520554247997444508040636526566551719396202550009393012691157",
 358 |     ),
 359 |   ],
 360 |   [
 361 |     BigInt(
 362 |       "3355402549169351700500518865338783382387571349497391475317206324155237401353",
 363 |     ),
 364 |     BigInt(
 365 |       "199541098009731541347317515995192175813554789571447733944970283654592727138",
 366 |     ),
 367 |     BigInt(
 368 |       "192100490643078165121235261796864975568292640203635147901612231594408079071",
 369 |     ),
 370 |   ],
 371 |   [
 372 |     BigInt(
 373 |       "1187019357602953326192019968809486933768550466167033084944727938441427050581",
 374 |     ),
 375 |     BigInt(
 376 |       "189525349641911362389041124808934468936759383310282010671081989585219065700",
 377 |     ),
 378 |     BigInt(
 379 |       "2831653363992091308880573627558515686245403755586311978724025292003353336665",
 380 |     ),
 381 |   ],
 382 |   [
 383 |     BigInt(
 384 |       "2052859812632218952608271535089179639890275494426396974475479657192657094698",
 385 |     ),
 386 |     BigInt(
 387 |       "1670756178709659908159049531058853320846231785448204274277900022176591811072",
 388 |     ),
 389 |     BigInt(
 390 |       "3538757242013734574731807289786598937548399719866320954894004830207085723125",
 391 |     ),
 392 |   ],
 393 |   [
 394 |     BigInt(
 395 |       "710549042741321081781917034337800036872214466705318638023070812391485261299",
 396 |     ),
 397 |     BigInt(
 398 |       "2345013122330545298606028187653996682275206910242635100920038943391319595180",
 399 |     ),
 400 |     BigInt(
 401 |       "3528369671971445493932880023233332035122954362711876290904323783426765912206",
 402 |     ),
 403 |   ],
 404 |   [
 405 |     BigInt(
 406 |       "1167120829038120978297497195837406760848728897181138760506162680655977700764",
 407 |     ),
 408 |     BigInt(
 409 |       "3073243357129146594530765548901087443775563058893907738967898816092270628884",
 410 |     ),
 411 |     BigInt(
 412 |       "378514724418106317738164464176041649567501099164061863402473942795977719726",
 413 |     ),
 414 |   ],
 415 |   [
 416 |     BigInt(
 417 |       "333391138410406330127594722511180398159664250722328578952158227406762627796",
 418 |     ),
 419 |     BigInt(
 420 |       "1727570175639917398410201375510924114487348765559913502662122372848626931905",
 421 |     ),
 422 |     BigInt(
 423 |       "968312190621809249603425066974405725769739606059422769908547372904403793174",
 424 |     ),
 425 |   ],
 426 |   [
 427 |     BigInt(
 428 |       "360659316299446405855194688051178331671817370423873014757323462844775818348",
 429 |     ),
 430 |     BigInt(
 431 |       "1386580151907705298970465943238806620109618995410132218037375811184684929291",
 432 |     ),
 433 |     BigInt(
 434 |       "3604888328937389309031638299660239238400230206645344173700074923133890528967",
 435 |     ),
 436 |   ],
 437 |   [
 438 |     BigInt(
 439 |       "2496185632263372962152518155651824899299616724241852816983268163379540137546",
 440 |     ),
 441 |     BigInt(
 442 |       "486538168871046887467737983064272608432052269868418721234810979756540672990",
 443 |     ),
 444 |     BigInt(
 445 |       "1558415498960552213241704009433360128041672577274390114589014204605400783336",
 446 |     ),
 447 |   ],
 448 |   [
 449 |     BigInt(
 450 |       "3512058327686147326577190314835092911156317204978509183234511559551181053926",
 451 |     ),
 452 |     BigInt(
 453 |       "2235429387083113882635494090887463486491842634403047716936833563914243946191",
 454 |     ),
 455 |     BigInt(
 456 |       "1290896777143878193192832813769470418518651727840187056683408155503813799882",
 457 |     ),
 458 |   ],
 459 |   [
 460 |     BigInt(
 461 |       "1143310336918357319571079551779316654556781203013096026972411429993634080835",
 462 |     ),
 463 |     BigInt(
 464 |       "3235435208525081966062419599803346573407862428113723170955762956243193422118",
 465 |     ),
 466 |     BigInt(
 467 |       "1293239921425673430660897025143433077974838969258268884994339615096356996604",
 468 |     ),
 469 |   ],
 470 |   [
 471 |     BigInt(
 472 |       "236252269127612784685426260840574970698541177557674806964960352572864382971",
 473 |     ),
 474 |     BigInt(
 475 |       "1733907592497266237374827232200506798207318263912423249709509725341212026275",
 476 |     ),
 477 |     BigInt(
 478 |       "302004309771755665128395814807589350526779835595021835389022325987048089868",
 479 |     ),
 480 |   ],
 481 |   [
 482 |     BigInt(
 483 |       "3018926838139221755384801385583867283206879023218491758435446265703006270945",
 484 |     ),
 485 |     BigInt(
 486 |       "39701437664873825906031098349904330565195980985885489447836580931425171297",
 487 |     ),
 488 |     BigInt(
 489 |       "908381723021746969965674308809436059628307487140174335882627549095646509778",
 490 |     ),
 491 |   ],
 492 |   [
 493 |     BigInt(
 494 |       "219062858908229855064136253265968615354041842047384625689776811853821594358",
 495 |     ),
 496 |     BigInt(
 497 |       "1283129863776453589317845316917890202859466483456216900835390291449830275503",
 498 |     ),
 499 |     BigInt(
 500 |       "418512623547417594896140369190919231877873410935689672661226540908900544012",
 501 |     ),
 502 |   ],
 503 |   [
 504 |     BigInt(
 505 |       "1792181590047131972851015200157890246436013346535432437041535789841136268632",
 506 |     ),
 507 |     BigInt(
 508 |       "370546432987510607338044736824316856592558876687225326692366316978098770516",
 509 |     ),
 510 |     BigInt(
 511 |       "3323437805230586112013581113386626899534419826098235300155664022709435756946",
 512 |     ),
 513 |   ],
 514 |   [
 515 |     BigInt(
 516 |       "910076621742039763058481476739499965761942516177975130656340375573185415877",
 517 |     ),
 518 |     BigInt(
 519 |       "1762188042455633427137702520675816545396284185254002959309669405982213803405",
 520 |     ),
 521 |     BigInt(
 522 |       "2186362253913140345102191078329764107619534641234549431429008219905315900520",
 523 |     ),
 524 |   ],
 525 |   [
 526 |     BigInt(
 527 |       "2230647725927681765419218738218528849146504088716182944327179019215826045083",
 528 |     ),
 529 |     BigInt(
 530 |       "1069243907556644434301190076451112491469636357133398376850435321160857761825",
 531 |     ),
 532 |     BigInt(
 533 |       "2695241469149243992683268025359863087303400907336026926662328156934068747593",
 534 |     ),
 535 |   ],
 536 |   [
 537 |     BigInt(
 538 |       "1361519681544413849831669554199151294308350560528931040264950307931824877035",
 539 |     ),
 540 |     BigInt(
 541 |       "1339116632207878730171031743761550901312154740800549632983325427035029084904",
 542 |     ),
 543 |     BigInt(
 544 |       "790593524918851401449292693473498591068920069246127392274811084156907468875",
 545 |     ),
 546 |   ],
 547 |   [
 548 |     BigInt(
 549 |       "2723400368331924254840192318398326090089058735091724263333980290765736363637",
 550 |     ),
 551 |     BigInt(
 552 |       "3457180265095920471443772463283225391927927225993685928066766687141729456030",
 553 |     ),
 554 |     BigInt(
 555 |       "1483675376954327086153452545475557749815683871577400883707749788555424847954",
 556 |     ),
 557 |   ],
 558 |   [
 559 |     BigInt(
 560 |       "2926303836265506736227240325795090239680154099205721426928300056982414025239",
 561 |     ),
 562 |     BigInt(
 563 |       "543969119775473768170832347411484329362572550684421616624136244239799475526",
 564 |     ),
 565 |     BigInt(
 566 |       "237401230683847084256617415614300816373730178313253487575312839074042461932",
 567 |     ),
 568 |   ],
 569 |   [
 570 |     BigInt(
 571 |       "844568412840391587862072008674263874021460074878949862892685736454654414423",
 572 |     ),
 573 |     BigInt(
 574 |       "151922054871708336050647150237534498235916969120198637893731715254687336644",
 575 |     ),
 576 |     BigInt(
 577 |       "1299332034710622815055321547569101119597030148120309411086203580212105652312",
 578 |     ),
 579 |   ],
 580 |   [
 581 |     BigInt(
 582 |       "487046922649899823989594814663418784068895385009696501386459462815688122993",
 583 |     ),
 584 |     BigInt(
 585 |       "1104883249092599185744249485896585912845784382683240114120846423960548576851",
 586 |     ),
 587 |     BigInt(
 588 |       "1458388705536282069567179348797334876446380557083422364875248475157495514484",
 589 |     ),
 590 |   ],
 591 |   [
 592 |     BigInt(
 593 |       "850248109622750774031817200193861444623975329881731864752464222442574976566",
 594 |     ),
 595 |     BigInt(
 596 |       "2885843173858536690032695698009109793537724845140477446409245651176355435722",
 597 |     ),
 598 |     BigInt(
 599 |       "3027068551635372249579348422266406787688980506275086097330568993357835463816",
 600 |     ),
 601 |   ],
 602 |   [
 603 |     BigInt(
 604 |       "3231892723647447539926175383213338123506134054432701323145045438168976970994",
 605 |     ),
 606 |     BigInt(
 607 |       "1719080830641935421242626784132692936776388194122314954558418655725251172826",
 608 |     ),
 609 |     BigInt(
 610 |       "1172253756541066126131022537343350498482225068791630219494878195815226839450",
 611 |     ),
 612 |   ],
 613 |   [
 614 |     BigInt(
 615 |       "1619232269633026603732619978083169293258272967781186544174521481891163985093",
 616 |     ),
 617 |     BigInt(
 618 |       "3495680684841853175973173610562400042003100419811771341346135531754869014567",
 619 |     ),
 620 |     BigInt(
 621 |       "1576161515913099892951745452471618612307857113799539794680346855318958552758",
 622 |     ),
 623 |   ],
 624 |   [
 625 |     BigInt(
 626 |       "2618326122974253423403350731396350223238201817594761152626832144510903048529",
 627 |     ),
 628 |     BigInt(
 629 |       "2696245132758436974032479782852265185094623165224532063951287925001108567649",
 630 |     ),
 631 |     BigInt(
 632 |       "930116505665110070247395429730201844026054810856263733273443066419816003444",
 633 |     ),
 634 |   ],
 635 |   [
 636 |     BigInt(
 637 |       "2786389174502246248523918824488629229455088716707062764363111940462137404076",
 638 |     ),
 639 |     BigInt(
 640 |       "1555260846425735320214671887347115247546042526197895180675436886484523605116",
 641 |     ),
 642 |     BigInt(
 643 |       "2306241912153325247392671742757902161446877415586158295423293240351799505917",
 644 |     ),
 645 |   ],
 646 |   [
 647 |     BigInt(
 648 |       "411529621724849932999694270803131456243889635467661223241617477462914950626",
 649 |     ),
 650 |     BigInt(
 651 |       "1542495485262286701469125140275904136434075186064076910329015697714211835205",
 652 |     ),
 653 |     BigInt(
 654 |       "1853045663799041100600825096887578544265580718909350942241802897995488264551",
 655 |     ),
 656 |   ],
 657 |   [
 658 |     BigInt(
 659 |       "2963055259497271220202739837493041799968576111953080503132045092194513937286",
 660 |     ),
 661 |     BigInt(
 662 |       "2303806870349915764285872605046527036748108533406243381676768310692344456050",
 663 |     ),
 664 |     BigInt(
 665 |       "2622104986201990620910286730213140904984256464479840856728424375142929278875",
 666 |     ),
 667 |   ],
 668 |   [
 669 |     BigInt(
 670 |       "2369987021925266811581727383184031736927816625797282287927222602539037105864",
 671 |     ),
 672 |     BigInt(
 673 |       "285070227712021899602056480426671736057274017903028992288878116056674401781",
 674 |     ),
 675 |     BigInt(
 676 |       "3034087076179360957800568733595959058628497428787907887933697691951454610691",
 677 |     ),
 678 |   ],
 679 |   [
 680 |     BigInt(
 681 |       "469095854351700119980323115747590868855368701825706298740201488006320881056",
 682 |     ),
 683 |     BigInt(
 684 |       "360001976264385426746283365024817520563236378289230404095383746911725100012",
 685 |     ),
 686 |     BigInt(
 687 |       "3438709327109021347267562000879503009590697221730578667498351600602230296178",
 688 |     ),
 689 |   ],
 690 |   [
 691 |     BigInt(
 692 |       "63573904800572228121671659287593650438456772568903228287754075619928214969",
 693 |     ),
 694 |     BigInt(
 695 |       "3470881855042989871434874691030920672110111605547839662680968354703074556970",
 696 |     ),
 697 |     BigInt(
 698 |       "724559311507950497340993415408274803001166693839947519425501269424891465492",
 699 |     ),
 700 |   ],
 701 |   [
 702 |     BigInt(
 703 |       "880409284677518997550768549487344416321062350742831373397603704465823658986",
 704 |     ),
 705 |     BigInt(
 706 |       "6876255662475867703077362872097208259197756317287339941435193538565586230",
 707 |     ),
 708 |     BigInt(
 709 |       "2701916445133770775447884812906226786217969545216086200932273680400909154638",
 710 |     ),
 711 |   ],
 712 |   [
 713 |     BigInt(
 714 |       "425152119158711585559310064242720816611629181537672850898056934507216982586",
 715 |     ),
 716 |     BigInt(
 717 |       "1475552998258917706756737045704649573088377604240716286977690565239187213744",
 718 |     ),
 719 |     BigInt(
 720 |       "2413772448122400684309006716414417978370152271397082147158000439863002593561",
 721 |     ),
 722 |   ],
 723 |   [
 724 |     BigInt(
 725 |       "392160855822256520519339260245328807036619920858503984710539815951012864164",
 726 |     ),
 727 |     BigInt(
 728 |       "1075036996503791536261050742318169965707018400307026402939804424927087093987",
 729 |     ),
 730 |     BigInt(
 731 |       "2176439430328703902070742432016450246365760303014562857296722712989275658921",
 732 |     ),
 733 |   ],
 734 |   [
 735 |     BigInt(
 736 |       "1413865976587623331051814207977382826721471106513581745229680113383908569693",
 737 |     ),
 738 |     BigInt(
 739 |       "4879283427490523253696177116563427032332223531862961281430108575019551814",
 740 |     ),
 741 |     BigInt(
 742 |       "3392583297537374046875199552977614390492290683707960975137418536812266544902",
 743 |     ),
 744 |   ],
 745 |   [
 746 |     BigInt(
 747 |       "3600854486849487646325182927019642276644093512133907046667282144129939150983",
 748 |     ),
 749 |     BigInt(
 750 |       "2779924664161372134024229593301361846129279572186444474616319283535189797834",
 751 |     ),
 752 |     BigInt(
 753 |       "2722699960903170449291146429799738181514821447014433304730310678334403972040",
 754 |     ),
 755 |   ],
 756 |   [
 757 |     BigInt(
 758 |       "819109815049226540285781191874507704729062681836086010078910930707209464699",
 759 |     ),
 760 |     BigInt(
 761 |       "3046121243742768013822760785918001632929744274211027071381357122228091333823",
 762 |     ),
 763 |     BigInt(
 764 |       "1339019590803056172509793134119156250729668216522001157582155155947567682278",
 765 |     ),
 766 |   ],
 767 |   [
 768 |     BigInt(
 769 |       "1933279639657506214789316403763326578443023901555983256955812717638093967201",
 770 |     ),
 771 |     BigInt(
 772 |       "2138221547112520744699126051903811860205771600821672121643894708182292213541",
 773 |     ),
 774 |     BigInt(
 775 |       "2694713515543641924097704224170357995809887124438248292930846280951601597065",
 776 |     ),
 777 |   ],
 778 |   [
 779 |     BigInt(
 780 |       "2471734202930133750093618989223585244499567111661178960753938272334153710615",
 781 |     ),
 782 |     BigInt(
 783 |       "504903761112092757611047718215309856203214372330635774577409639907729993533",
 784 |     ),
 785 |     BigInt(
 786 |       "1943979703748281357156510253941035712048221353507135074336243405478613241290",
 787 |     ),
 788 |   ],
 789 |   [
 790 |     BigInt(
 791 |       "684525210957572142559049112233609445802004614280157992196913315652663518936",
 792 |     ),
 793 |     BigInt(
 794 |       "1705585400798782397786453706717059483604368413512485532079242223503960814508",
 795 |     ),
 796 |     BigInt(
 797 |       "192429517716023021556170942988476050278432319516032402725586427701913624665",
 798 |     ),
 799 |   ],
 800 |   [
 801 |     BigInt(
 802 |       "1586493702243128040549584165333371192888583026298039652930372758731750166765",
 803 |     ),
 804 |     BigInt(
 805 |       "686072673323546915014972146032384917012218151266600268450347114036285993377",
 806 |     ),
 807 |     BigInt(
 808 |       "3464340397998075738891129996710075228740496767934137465519455338004332839215",
 809 |     ),
 810 |   ],
 811 |   [
 812 |     BigInt(
 813 |       "2805249176617071054530589390406083958753103601524808155663551392362371834663",
 814 |     ),
 815 |     BigInt(
 816 |       "667746464250968521164727418691487653339733392025160477655836902744186489526",
 817 |     ),
 818 |     BigInt(
 819 |       "1131527712905109997177270289411406385352032457456054589588342450404257139778",
 820 |     ),
 821 |   ],
 822 |   [
 823 |     BigInt(
 824 |       "1908969485750011212309284349900149072003218505891252313183123635318886241171",
 825 |     ),
 826 |     BigInt(
 827 |       "1025257076985551890132050019084873267454083056307650830147063480409707787695",
 828 |     ),
 829 |     BigInt(
 830 |       "2153175291918371429502545470578981828372846236838301412119329786849737957977",
 831 |     ),
 832 |   ],
 833 |   [
 834 |     BigInt(
 835 |       "3410257749736714576487217882785226905621212230027780855361670645857085424384",
 836 |     ),
 837 |     BigInt(
 838 |       "3442969106887588154491488961893254739289120695377621434680934888062399029952",
 839 |     ),
 840 |     BigInt(
 841 |       "3029953900235731770255937704976720759948880815387104275525268727341390470237",
 842 |     ),
 843 |   ],
 844 |   [
 845 |     BigInt(
 846 |       "85453456084781138713939104192561924536933417707871501802199311333127894466",
 847 |     ),
 848 |     BigInt(
 849 |       "2730629666577257820220329078741301754580009106438115341296453318350676425129",
 850 |     ),
 851 |     BigInt(
 852 |       "178242450661072967256438102630920745430303027840919213764087927763335940415",
 853 |     ),
 854 |   ],
 855 |   [
 856 |     BigInt(
 857 |       "2844589222514708695700541363167856718216388819406388706818431442998498677557",
 858 |     ),
 859 |     BigInt(
 860 |       "3547876269219141094308889387292091231377253967587961309624916269569559952944",
 861 |     ),
 862 |     BigInt(
 863 |       "2525005406762984211707203144785482908331876505006839217175334833739957826850",
 864 |     ),
 865 |   ],
 866 |   [
 867 |     BigInt(
 868 |       "3096397013555211396701910432830904669391580557191845136003938801598654871345",
 869 |     ),
 870 |     BigInt(
 871 |       "574424067119200181933992948252007230348512600107123873197603373898923821490",
 872 |     ),
 873 |     BigInt(
 874 |       "1714030696055067278349157346067719307863507310709155690164546226450579547098",
 875 |     ),
 876 |   ],
 877 |   [
 878 |     BigInt(
 879 |       "2339895272202694698739231405357972261413383527237194045718815176814132612501",
 880 |     ),
 881 |     BigInt(
 882 |       "3562501318971895161271663840954705079797767042115717360959659475564651685069",
 883 |     ),
 884 |     BigInt(
 885 |       "69069358687197963617161747606993436483967992689488259107924379545671193749",
 886 |     ),
 887 |   ],
 888 |   [
 889 |     BigInt(
 890 |       "2614502738369008850475068874731531583863538486212691941619835266611116051561",
 891 |     ),
 892 |     BigInt(
 893 |       "655247349763023251625727726218660142895322325659927266813592114640858573566",
 894 |     ),
 895 |     BigInt(
 896 |       "2305235672527595714255517865498269719545193172975330668070873705108690670678",
 897 |     ),
 898 |   ],
 899 |   [
 900 |     BigInt(
 901 |       "926416070297755413261159098243058134401665060349723804040714357642180531931",
 902 |     ),
 903 |     BigInt(
 904 |       "866523735635840246543516964237513287099659681479228450791071595433217821460",
 905 |     ),
 906 |     BigInt(
 907 |       "2284334068466681424919271582037156124891004191915573957556691163266198707693",
 908 |     ),
 909 |   ],
 910 |   [
 911 |     BigInt(
 912 |       "1812588309302477291425732810913354633465435706480768615104211305579383928792",
 913 |     ),
 914 |     BigInt(
 915 |       "2836899808619013605432050476764608707770404125005720004551836441247917488507",
 916 |     ),
 917 |     BigInt(
 918 |       "2989087789022865112405242078196235025698647423649950459911546051695688370523",
 919 |     ),
 920 |   ],
 921 |   [
 922 |     BigInt(
 923 |       "68056284404189102136488263779598243992465747932368669388126367131855404486",
 924 |     ),
 925 |     BigInt(
 926 |       "505425339250887519581119854377342241317528319745596963584548343662758204398",
 927 |     ),
 928 |     BigInt(
 929 |       "2118963546856545068961709089296976921067035227488975882615462246481055679215",
 930 |     ),
 931 |   ],
 932 |   [
 933 |     BigInt(
 934 |       "2253872596319969096156004495313034590996995209785432485705134570745135149681",
 935 |     ),
 936 |     BigInt(
 937 |       "1625090409149943603241183848936692198923183279116014478406452426158572703264",
 938 |     ),
 939 |     BigInt(
 940 |       "179139838844452470348634657368199622305888473747024389514258107503778442495",
 941 |     ),
 942 |   ],
 943 |   [
 944 |     BigInt(
 945 |       "1567067018147735642071130442904093290030432522257811793540290101391210410341",
 946 |     ),
 947 |     BigInt(
 948 |       "2737301854006865242314806979738760349397411136469975337509958305470398783585",
 949 |     ),
 950 |     BigInt(
 951 |       "3002738216460904473515791428798860225499078134627026021350799206894618186256",
 952 |     ),
 953 |   ],
 954 |   [
 955 |     BigInt(
 956 |       "374029488099466837453096950537275565120689146401077127482884887409712315162",
 957 |     ),
 958 |     BigInt(
 959 |       "973403256517481077805460710540468856199855789930951602150773500862180885363",
 960 |     ),
 961 |     BigInt(
 962 |       "2691967457038172130555117632010860984519926022632800605713473799739632878867",
 963 |     ),
 964 |   ],
 965 |   [
 966 |     BigInt(
 967 |       "3515906794910381201365530594248181418811879320679684239326734893975752012109",
 968 |     ),
 969 |     BigInt(
 970 |       "148057579455448384062325089530558091463206199724854022070244924642222283388",
 971 |     ),
 972 |     BigInt(
 973 |       "1541588700238272710315890873051237741033408846596322948443180470429851502842",
 974 |     ),
 975 |   ],
 976 |   [
 977 |     BigInt(
 978 |       "147013865879011936545137344076637170977925826031496203944786839068852795297",
 979 |     ),
 980 |     BigInt(
 981 |       "2630278389304735265620281704608245039972003761509102213752997636382302839857",
 982 |     ),
 983 |     BigInt(
 984 |       "1359048670759642844930007747955701205155822111403150159614453244477853867621",
 985 |     ),
 986 |   ],
 987 |   [
 988 |     BigInt(
 989 |       "2438984569205812336319229336885480537793786558293523767186829418969842616677",
 990 |     ),
 991 |     BigInt(
 992 |       "2137792255841525507649318539501906353254503076308308692873313199435029594138",
 993 |     ),
 994 |     BigInt(
 995 |       "2262318076430740712267739371170174514379142884859595360065535117601097652755",
 996 |     ),
 997 |   ],
 998 |   [
 999 |     BigInt(
1000 |       "2792703718581084537295613508201818489836796608902614779596544185252826291584",
1001 |     ),
1002 |     BigInt(
1003 |       "2294173715793292812015960640392421991604150133581218254866878921346561546149",
1004 |     ),
1005 |     BigInt(
1006 |       "2770011224727997178743274791849308200493823127651418989170761007078565678171",
1007 |     ),
1008 |   ],
1009 | ];
1010 | 


--------------------------------------------------------------------------------
/src/builtins/poseidon/poseidon.ts:
--------------------------------------------------------------------------------
 1 | //This poseidon hash implementation was inspired by the following python one:
 2 | //https://github.com/CryptoExperts/poseidon/blob/main/sage/poseidon.sage
 3 | 
 4 | function hadesPermutation(values: bigint[], params: HadesParamsType): bigint[] {
 5 |   var roundIdx: number = 0;
 6 |   for (var i = 0; i < params.Rf / 2; i++) {
 7 |     values = hadesRound(values, params, true, roundIdx);
 8 |     roundIdx += 1;
 9 |   }
10 |   for (var i = 0; i < params.Rp; i++) {
11 |     values = hadesRound(values, params, false, roundIdx);
12 |     roundIdx += 1;
13 |   }
14 |   for (var i = 0; i < params.Rf / 2; i++) {
15 |     values = hadesRound(values, params, true, roundIdx);
16 |     roundIdx += 1;
17 |   }
18 |   return values;
19 | }
20 | 
21 | function hadesRound(
22 |   values: bigint[],
23 |   params: HadesParamsType,
24 |   isFullRound: boolean,
25 |   roundIdx: number,
26 | ): bigint[] {
27 |   values = modAddVectors(values, params.ark[roundIdx]);
28 | 
29 |   if (isFullRound) {
30 |     for (var i = 0; i < values.length; i++) {
31 |       values[i] = modPow(values[i], 3);
32 |     }
33 |   } else {
34 |     values[values.length - 1] = modPow(values[values.length - 1], 3);
35 |   }
36 |   values = modMulMatrixVector(params.mds, values);
37 |   return values;
38 | }
39 | 
40 | function poseidon(x: bigint, y: bigint, z: bigint): bigint[] {
41 |   const params: HadesParamsType = {
42 |     r: 2,
43 |     c: 1,
44 |     m: 3,
45 |     Rf: 8,
46 |     Rp: 83,
47 |     nRounds: 91,
48 |     outputSize: 1,
49 |     ark: roundKeys,
50 |     mds: matrix,
51 |   };
52 |   var values: bigint[] = [x, y, z];
53 |   return hadesPermutation(values, params);
54 | }
55 | 
56 | function modAddVectors(A: bigint[], B: bigint[]): bigint[] {
57 |   var res: bigint[] = A;
58 |   for (var i = 0; i < A.length; i++) {
59 |     res[i] = modAdd(res[i], B[i]);
60 |   }
61 |   return res;
62 | }
63 | 
64 | function modMulMatrixVector(A: bigint[][], X: bigint[]): bigint[] {
65 |   var res: bigint[] = Array(X.length).fill(BigInt(0));
66 |   for (var i = 0; i < A.length; i++) {
67 |     for (var j = 0; j < A[0].length; j++) {
68 |       res[i] = modAdd(res[i], modMul(A[i][j], X[j]));
69 |     }
70 |   }
71 |   return res;
72 | }
73 | 


--------------------------------------------------------------------------------
/src/builtins/range_check/range_check.ts:
--------------------------------------------------------------------------------
 1 | const RC_BOUND: bigint = BigInt(2 ** 128);
 2 | 
 3 | // performs a range check for the input num of type bigint.
 4 | function rangeCheck(num: bigint): bigint {
 5 |   if (num < RC_BOUND) {
 6 |     return num;
 7 |   } else {
 8 |     throw new InvalidRangeError("Number out of range");
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/builtins/range_check96/range_check96.ts:
--------------------------------------------------------------------------------
 1 | const RC96_BOUND: bigint = BigInt(2 ** 96);
 2 | 
 3 | // performs a range check for the input num of type bigint.
 4 | function rangeCheck96(num: bigint): bigint {
 5 |   if (num < RC96_BOUND) {
 6 |     return num;
 7 |   } else {
 8 |     throw new InvalidRangeError("Number out of range");
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/tests.ts:
--------------------------------------------------------------------------------
  1 | function testRunner() {
  2 |   if (typeof GasTap === "undefined") {
  3 |     eval(
  4 |       UrlFetchApp.fetch(
  5 |         "https://raw.githubusercontent.com/huan/gast/master/src/gas-tap-lib.js",
  6 |       ).getContentText(),
  7 |     );
  8 |   }
  9 | 
 10 |   var test = new GasTap();
 11 | 
 12 |   test("instruction decoder", (t) => {
 13 |     var encodedInstruction: string = "0x208b7fff7fff7ffe";
 14 |     const instruction: [any[]] = DECODE_INSTRUCTION(encodedInstruction);
 15 |     const expectedInstruction: [any[]] = [
 16 |       ["Ret", "[FP - 2]", "[FP - 1]", "jmp abs", "AP", "Dst"],
 17 |     ];
 18 |     t.deepEqual(instruction, expectedInstruction);
 19 |   });
 20 | 
 21 |   test("object from array", (t) => {
 22 |     const keys: string[] = ["a", "b", "c"];
 23 |     const values: number[] = [1, 2, 3];
 24 |     const target: any = objectFromEntries(keys, values);
 25 |     const expectedTarget = { b: 2.0, a: 1.0, c: 3.0 };
 26 |     t.deepEqual(target, expectedTarget);
 27 |   });
 28 | 
 29 |   test("ecAdd", (t) => {
 30 |     var P = new AffinePoint(
 31 |       "45477851653901153117103016505176923677805691341513469374986918421704783798",
 32 |       "183085939200008105303514891306249502070824714566204820793608690653248096343",
 33 |     );
 34 |     var Q = new AffinePoint(
 35 |       "1110490586165327629491026518265864493948957016447342824580924691292949995955",
 36 |       "3150911138446828848637348285516855379003902600135909185517179002759670428860",
 37 |     );
 38 |     var minusP = new AffinePoint(
 39 |       "45477851653901153117103016505176923677805691341513469374986918421704783798",
 40 |       "-183085939200008105303514891306249502070824714566204820793608690653248096343",
 41 |     );
 42 |     var neutralElement = new AffinePoint("0x0", "0x0", true);
 43 | 
 44 |     var R: AffinePoint;
 45 |     var expectedR;
 46 | 
 47 |     t.deepEqual(ecAdd(P, neutralElement), P, "P + 0 = P");
 48 | 
 49 |     t.deepEqual(ecAdd(neutralElement, P), P, "0 + P = P");
 50 | 
 51 |     t.equal(ecAdd(P, minusP).isNeutralElement, true, "P - P = 0");
 52 | 
 53 |     R = ecAdd(P, P);
 54 |     expectedR = new AffinePoint(
 55 |       "1968885970339083619948296146201104092252508104349267720068326878178341392969",
 56 |       "593121236708823356289653686480454355603982629001053929931980663109960391985",
 57 |     );
 58 |     t.deepEqual(R, expectedR, "P + P");
 59 | 
 60 |     R = ecAdd(P, Q);
 61 |     expectedR = new AffinePoint(
 62 |       "2825233123465961750980798694652743017262313358557354910947070689454726096961",
 63 |       "3554824400633731496516020947624430028316074332303691877626182575674539922487",
 64 |     );
 65 |     t.deepEqual(R, expectedR, "P + Q");
 66 |   });
 67 | 
 68 |   test("ecMul", (t) => {
 69 |     var P = new AffinePoint(
 70 |       "2381583528819525045296122742815875182495256257584749503448788652392977649575",
 71 |       "2067108964175809973602195624719018122069259275804588771867408794862963975607",
 72 |     );
 73 |     var expectedR = new AffinePoint(
 74 |       "2851021747692556495134621021330740661724372292432922651722907298519557703909",
 75 |       "2640080408746596207685151085183790981626794605058347843666475762850263746578",
 76 |     );
 77 |     var m = BigInt(234);
 78 |     t.equal(ecMul(BigInt(0), P).isNeutralElement, true, "0*P");
 79 |     t.deepEqual(ecMul(m, P), expectedR, "m*P");
 80 |   });
 81 | 
 82 |   test("pedersen hash", (t) => {
 83 |     var hash: string = pedersen(
 84 |       BigInt(
 85 |         "0x03d937c035c878245caf64531a5756109c53068da139362728feb561405371cb",
 86 |       ),
 87 |       BigInt(
 88 |         "0x0208a0a10250e382e1e4bbe2880906c2791bf6275695e02fbbc6aeff9cd8b31a",
 89 |       ),
 90 |     ).toString(16);
 91 |     var expectedHash: string =
 92 |       "30e480bed5fe53fa909cc0f8c4d99b8f9f2c016be4c41e13a4848797979c662";
 93 |     t.equal(hash, expectedHash);
 94 |   });
 95 | 
 96 |   test("ecdsa", (t) => {
 97 |     var privateKey: bigint = BigInt(
 98 |       "3518502788666131213697322783095070105526743751716087489154079457884512865583",
 99 |     );
100 |     var publicKey: AffinePoint = ecMul(privateKey, GENERATOR);
101 |     var message: bigint = BigInt(
102 |       "13434234141348937597925294754859245298359825",
103 |     );
104 |     var signature: SignatureType = signMessage(message, privateKey);
105 |     t.ok(
106 |       verifySignature(signature, message, publicKey),
107 |       "signature verification",
108 |     );
109 |   });
110 | 
111 |   test.finish();
112 | }
113 | 


--------------------------------------------------------------------------------
/src/ui/Code.ts:
--------------------------------------------------------------------------------
  1 | function DECODE_INSTRUCTION(encodedInstruction: string): [any[]] {
  2 |   const header: String[] = [
  3 |     "Opcode",
  4 |     "Dst",
  5 |     "Op",
  6 |     "Pc Update",
  7 |     "Ap Update",
  8 |     "Fp Update",
  9 |   ];
 10 |   try {
 11 |     if (encodedInstruction === "Program") {
 12 |       return [header];
 13 |     } else {
 14 |       const instruction: decodedInstruction = decodeInstruction(
 15 |         BigInt(encodedInstruction),
 16 |       );
 17 | 
 18 |       const dst: string =
 19 |         `${instruction.DstRegister} ${instruction.DstOffset === 0 ? "" : (instruction.DstOffset > 0 ? "+ " : "- ") + Math.abs(instruction.DstOffset)}`.trim();
 20 |       const op0: string =
 21 |         `${instruction.Op0Register} ${instruction.Op0Offset === 0 ? "" : (instruction.Op0Offset > 0 ? "+ " : "- ") + Math.abs(instruction.Op0Offset)}`.trim();
 22 |       const op1: string =
 23 |         `${instruction.Op1Register === Op1Src.Op0 ? `[${op0}]` : instruction.Op1Register} ${instruction.Op1Offset === 0 ? "" : (instruction.Op1Offset > 0 ? "+ " : "- ") + Math.abs(instruction.Op1Offset)}`.trim();
 24 | 
 25 |       let op: string;
 26 |       switch (instruction.ResLogic) {
 27 |         case ResLogics.Op1:
 28 |           op = `[${op1}]`;
 29 |           break;
 30 |         case ResLogics.Add:
 31 |           op = `[${op0}] + [${op1}]`;
 32 |           break;
 33 |         case ResLogics.Mul:
 34 |           op = `[${op0}] * [${op1}]`;
 35 |           break;
 36 |       }
 37 |       const pcUpdate: string =
 38 |         instruction.PcUpdate === PcUpdates.Regular
 39 |           ? `PC + ${size(instruction)}`
 40 |           : instruction.PcUpdate;
 41 |       return [
 42 |         [
 43 |           instruction.Opcode,
 44 |           `[${dst}]`,
 45 |           op,
 46 |           pcUpdate,
 47 |           instruction.ApUpdate,
 48 |           instruction.FpUpdate,
 49 |         ],
 50 |       ];
 51 |     }
 52 |   } catch (error) {
 53 |     Logger.log(error);
 54 |     if (error instanceof NonZeroHighBitError) {
 55 |       return [["", "", toSignedInteger(encodedInstruction)]];
 56 |     }
 57 |     return [[""]];
 58 |   }
 59 | }
 60 | 
 61 | function TO_SIGNED_INTEGER(encodedInstruction: string): [any[]] {
 62 |   return [["", "", toSignedInteger(BigInt(encodedInstruction)).toString(10)]];
 63 | }
 64 | 
 65 | function BITWISE(inputs: string[][]): string[] {
 66 |   if (hasEmptyCell(inputs)) {
 67 |     return [""];
 68 |   }
 69 |   const [x, y] = inputs.flat();
 70 |   return [
 71 |     toSignedInteger(
 72 |       bitwiseAnd(toUnsignedInteger(x), toUnsignedInteger(y)),
 73 |     ).toString(10),
 74 |     toSignedInteger(
 75 |       bitwiseXor(toUnsignedInteger(x), toUnsignedInteger(y)),
 76 |     ).toString(10),
 77 |     toSignedInteger(
 78 |       bitwiseOr(toUnsignedInteger(x), toUnsignedInteger(y)),
 79 |     ).toString(10),
 80 |   ];
 81 | }
 82 | 
 83 | function EC_OP(inputs: string[][]): string[] {
 84 |   if (hasEmptyCell(inputs)) {
 85 |     return [""];
 86 |   }
 87 |   const [px, py, qx, qy, m] = inputs.flat();
 88 |   let p = new AffinePoint(px, py);
 89 |   let q = new AffinePoint(qx, qy);
 90 |   let ecOpResult: AffinePoint = ecOp(toUnsignedInteger(m), p, q);
 91 |   return [
 92 |     toSignedInteger(ecOpResult.x).toString(10),
 93 |     toSignedInteger(ecOpResult.y).toString(10),
 94 |   ];
 95 | }
 96 | 
 97 | // function SIGN_ECDSA(
 98 | //   message: number | string,
 99 | //   private_key: number | string,
100 | // ): SignatureType {
101 | //   return signMessage(BigInt(message), BigInt(private_key));
102 | // }
103 | 
104 | // function CHECK_ECDSA_SIGNATURE(inputs: string[][]): string[] {
105 | //   if (hasEmptyCell(inputs)) {
106 | //     return [""];
107 | //   }
108 | //   const [r, s, message, x, y] = inputs.flat();
109 | //   var signature: SignatureType = { r: BigInt(r), s: BigInt(s) };
110 | //   var public_key = new AffinePoint(String(x), String(y));
111 | //   return [verifySignature(signature, BigInt(message), public_key)];
112 | // }
113 | 
114 | function PEDERSEN(inputs: string[][]): string[] {
115 |   if (hasEmptyCell(inputs)) {
116 |     return [""];
117 |   }
118 |   const [x, y] = inputs.flat();
119 |   return [
120 |     toSignedInteger(
121 |       pedersen(toUnsignedInteger(x), toUnsignedInteger(y)),
122 |     ).toString(10),
123 |   ];
124 | }
125 | 
126 | function KECCAK(inputs: string[][]): string[] {
127 |   if (hasEmptyCell(inputs)) {
128 |     return [""];
129 |   }
130 |   let inputsFlattened: string[] = inputs.flat();
131 |   const inputHash = concatBytes(
132 |     ...inputsFlattened.map((value) => {
133 |       return numberToBytesLE(toUnsignedInteger(value), 25);
134 |     }),
135 |   );
136 |   const state = u32(inputHash);
137 |   keccakP(state);
138 |   const finalState = u8(state);
139 |   const KECCAK_BYTES = 25;
140 |   const outputs = Array.from({ length: 8 }, (_, i) =>
141 |     finalState.slice(i * KECCAK_BYTES, (i + 1) * KECCAK_BYTES),
142 |   ).map(bytesToNumberLE);
143 |   return outputs.map((output) => toSignedInteger(output).toString(10));
144 | }
145 | 
146 | function POSEIDON(inputs: string[][]): string[] {
147 |   if (hasEmptyCell(inputs)) {
148 |     return [""];
149 |   }
150 |   const [x, y, z] = inputs.flat();
151 |   let poseidonResult: bigint[] = poseidon(
152 |     toUnsignedInteger(x),
153 |     toUnsignedInteger(y),
154 |     toUnsignedInteger(z),
155 |   );
156 |   return [
157 |     toSignedInteger(poseidonResult[0]).toString(10),
158 |     toSignedInteger(poseidonResult[1]).toString(10),
159 |     toSignedInteger(poseidonResult[2]).toString(10),
160 |   ];
161 | }
162 | 
163 | function RANGE_CHECK(inputs: string): string[] {
164 |   return [toSignedInteger(rangeCheck(toUnsignedInteger(inputs))).toString(10)];
165 | }
166 | 
167 | function RANGE_CHECK96(inputs: string): string[] {
168 |   return [
169 |     toSignedInteger(rangeCheck96(toUnsignedInteger(inputs))).toString(10),
170 |   ];
171 | }
172 | 
173 | function GET_FLAGS_AND_OFFSETS(encodedInstruction: string): number[][] {
174 |   const { dstOffset, op0Offset, op1Offset, flags } = getTraceInfo(
175 |     BigInt(encodedInstruction),
176 |   );
177 | 
178 |   let traceFlags: number[] = flags.map((f, i, arr) =>
179 |     parseInt(arr.slice(i).reverse().join(""), 2),
180 |   );
181 | 
182 |   return [[dstOffset, op0Offset, op1Offset, ...traceFlags]];
183 | }
184 | 
185 | function IS_CELL(input: string | number): boolean {
186 |   return isCell(input.toString(10));
187 | }
188 | 


--------------------------------------------------------------------------------
/src/ui/api.ts:
--------------------------------------------------------------------------------
 1 | interface Request {
 2 |   _?: any;
 3 |   postData?: {
 4 |     contents?: string;
 5 |     type?: string;
 6 |   };
 7 | }
 8 | 
 9 | interface JsonData {
10 |   data: string[];
11 | }
12 | 
13 | /*
14 | The endpoint to use is : "https://script.google.com/macros/s/<DEPLOYMENT_ID>/exec".
15 | Make sure to set Content-Type as "application/json" in your request.
16 | Then, in the body pass the compiled cairo json file.
17 | 
18 | The response will be a json as such :
19 | {'trace': [[pc0,fp0,ap0],
20 |             [pc1,fp1,ap1],
21 |             ...,
22 |             ['<FINAL_PC>','<FINAL_FP>',apn]],
23 |  'memory': [['<FINAL_FP>'],
24 |             ['<FINAL_PC>'],
25 |             [m0],...]]}
26 | */
27 | const doPost = (request: Request) => {
28 |   const { postData: { contents, type } = {} } = request;
29 | 
30 |   if (type === "application/json") {
31 |     clear();
32 |     const jsonData: JsonData = JSON.parse(contents);
33 |     loadProgram(jsonData.data);
34 |     runUntilPc();
35 | 
36 |     const runSheet =
37 |       SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Run");
38 | 
39 |     const traceValues: any[][] = runSheet
40 |       .getRange("A2:C")
41 |       .getValues()
42 |       .filter((row) => row.some((cell) => cell !== ""));
43 | 
44 |     const memoryValues: any[][] = runSheet
45 |       .getRange("G2:G")
46 |       .getValues()
47 |       .filter((row) => row[0] !== "");
48 | 
49 |     const result = {
50 |       trace: traceValues,
51 |       memory: memoryValues,
52 |     };
53 | 
54 |     return ContentService.createTextOutput(JSON.stringify(result)).setMimeType(
55 |       ContentService.MimeType.JSON,
56 |     );
57 |   }
58 | };
59 | 


--------------------------------------------------------------------------------
/src/ui/dialog.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 |   <head>
  4 |     <link
  5 |       rel="stylesheet"
  6 |       href="https://ssl.gstatic.com/docs/script/css/add-ons.css"
  7 |     />
  8 |     <style>
  9 |       /* Global Styles */
 10 |       body {
 11 |         font-family: sans-serif;
 12 |         margin: 0;
 13 |         padding: 0;
 14 |         display: flex;
 15 |         justify-content: center;
 16 |         align-items: center;
 17 |         height: 100vh;
 18 |         background-color: #f9f9f9;
 19 |         color: #333;
 20 |       }
 21 | 
 22 |       /* Card Container */
 23 |       .container {
 24 |         background: #ffffff;
 25 |         border-radius: 12px;
 26 |         box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 27 |         padding: 2rem;
 28 |         width: 100%;
 29 |         max-width: 400px;
 30 |         text-align: center;
 31 |       }
 32 | 
 33 |       /* File Input */
 34 |       #program {
 35 |         display: none;
 36 |       }
 37 | 
 38 |       .file-label {
 39 |         display: inline-block;
 40 |         padding: 0.75rem 1.5rem;
 41 |         font-size: 1rem;
 42 |         color: #fff;
 43 |         background-color: #007bff;
 44 |         border-radius: 8px;
 45 |         cursor: pointer;
 46 |         transition: background-color 0.3s ease;
 47 |         margin-bottom: 1.5rem;
 48 |       }
 49 | 
 50 |       .file-label:hover {
 51 |         background-color: #0056b3;
 52 |       }
 53 | 
 54 |       /* Select Inputs */
 55 |       label {
 56 |         display: block;
 57 |         text-align: left;
 58 |         font-size: 1rem;
 59 |         margin-bottom: 0.5rem;
 60 |         color: #666;
 61 |       }
 62 | 
 63 |       select {
 64 |         width: 100%;
 65 |         /* padding: 0.75rem; */
 66 |         border: 1px solid #ccc;
 67 |         border-radius: 8px;
 68 |         font-size: 0.8rem;
 69 |         background-color: #f5f5f5;
 70 |         color: #333;
 71 |         appearance: none;
 72 |         margin-bottom: 1.5rem;
 73 |         outline: none;
 74 |         transition:
 75 |           background-color 0.3s ease,
 76 |           border-color 0.3s ease;
 77 |       }
 78 | 
 79 |       /* On hover */
 80 |       select:hover {
 81 |         background-color: #e0e0e0; /* Gray background when hovered */
 82 |       }
 83 | 
 84 |       /* On focus */
 85 |       select:focus {
 86 |         border-color: #007bff; /* Blue border on focus */
 87 |         background-color: #eaeaea; /* Lighter gray background */
 88 |       }
 89 | 
 90 |       select::-ms-expand {
 91 |         display: none;
 92 |       }
 93 | 
 94 |       /* Styling for selected option (if not displaying correctly) */
 95 |       select option {
 96 |         background-color: #fff;
 97 |         color: #333;
 98 |       }
 99 | 
100 |       /* Buttons */
101 |       #loadButton {
102 |         background: #007bff;
103 |         color: #ffffff;
104 |         padding: 0.75rem 1.5rem;
105 |         font-size: 1rem;
106 |         border: none;
107 |         border-radius: 8px;
108 |         cursor: pointer;
109 |         transition: background-color 0.3s ease;
110 |         text-align: center;
111 |         display: inline-flex;
112 |         align-items: center;
113 |         justify-content: center;
114 |         width: 100%;
115 |         margin-top: 1rem;
116 |       }
117 | 
118 |       #loadButton:disabled {
119 |         background-color: #d6d6d6;
120 |         cursor: not-allowed;
121 |       }
122 | 
123 |       #loadButton:hover:not(:disabled) {
124 |         background-color: #0056b3;
125 |       }
126 | 
127 |       /* Progress Status */
128 |       #progressStatus {
129 |         margin-top: 1rem;
130 |         font-size: 0.9rem;
131 |         color: #555;
132 |         font-style: italic;
133 |       }
134 | 
135 |       /* Titles */
136 |       p {
137 |         font-weight: 500;
138 |         font-size: 1rem;
139 |         color: #666;
140 |         margin: 1rem 0;
141 |       }
142 |     </style>
143 |     <script>
144 |       let compiledJson = null;
145 | 
146 |       function closeDialog() {
147 |         google.script.host.close();
148 |       }
149 | 
150 |       function getProgress() {
151 |         google.script.run.withSuccessHandler(updateProgress).getProgress();
152 |       }
153 | 
154 |       function updateProgress(data) {
155 |         if (data && data.current) {
156 |           document.getElementById("progressStatus").textContent = data.current;
157 |         }
158 |         setTimeout(getProgress, 10);
159 |       }
160 | 
161 |       window.addEventListener("load", getProgress);
162 | 
163 |       function loadProgramRunner() {
164 |         if (!compiledJson) {
165 |           alert("Please select a file before proceeding.");
166 |           return;
167 |         }
168 |         const selectedRunnerMode = document.getElementById("runnerMode").value;
169 |         const selectedLayout = document.getElementById("layoutPicker").value;
170 | 
171 |         document.getElementById("loadButton").textContent = "Loading...";
172 |         document.getElementById("loadButton").disabled = true;
173 |         document.getElementById("progressStatus").textContent =
174 |           "Fetching program...";
175 | 
176 |         google.script.run
177 |           .withSuccessHandler(closeDialog)
178 |           .loadProgram(
179 |             JSON.stringify(compiledJson, null, 2),
180 |             selectedRunnerMode,
181 |             selectedLayout,
182 |           );
183 |       }
184 | 
185 |       function onFileLoad(event) {
186 |         compiledJson = JSON.parse(event.target.result);
187 |         document.getElementById("loadButton").disabled = false;
188 |       }
189 | 
190 |       function onFileChange(event) {
191 |         var fileReader = new FileReader();
192 |         fileReader.onload = onFileLoad;
193 |         fileReader.readAsText(event.target.files[0]);
194 |         var fileName = event.target.files[0].name;
195 |         document.querySelector(".file-label").textContent = fileName;
196 |       }
197 | 
198 |       function onApiLoad() {
199 |         document
200 |           .getElementById("program")
201 |           .addEventListener("change", onFileChange);
202 |       }
203 |     </script>
204 |   </head>
205 |   <body>
206 |     <div class="container">
207 |       <label for="program" class="file-label"
208 |         >Select a .json cairo-compiled file</label
209 |       >
210 |       <input id="program" type="file" accept="application/json" />
211 | 
212 |       <div>
213 |         <label for="runnerMode">Select the runner configuration:</label>
214 |         <select id="runnerMode">
215 |           <option value="execution">Execution mode</option>
216 |           <option value="proof">Proof mode</option>
217 |         </select>
218 |       </div>
219 | 
220 |       <div>
221 |         <label for="layoutPicker">Pick a layout:</label>
222 |         <select id="layoutPicker">
223 |           <option value="plain">Plain</option>
224 |           <option value="small">Small</option>
225 |           <option value="dex">Dex</option>
226 |           <option value="recursive">Recursive</option>
227 |           <option value="starknet_with_keccak">Starknet with Keccak</option>
228 |           <option value="recursive_large_output">Recursive large output</option>
229 |           <option value="recursive_with_poseidon">
230 |             Recursive with Poseidon
231 |           </option>
232 |           <option value="all_cairo">All Cairo</option>
233 |           <option value="all_solidity">All Solidity</option>
234 |           <option value="dynamic">Dynamic</option>
235 |         </select>
236 |       </div>
237 | 
238 |       <button id="loadButton" onclick="loadProgramRunner()" disabled="true">
239 |         Load Program
240 |       </button>
241 |       <div id="progressStatus"></div>
242 |     </div>
243 | 
244 |     <script src="https://apis.google.com/js/api.js?onload=onApiLoad"></script>
245 |   </body>
246 | </html>
247 | 


--------------------------------------------------------------------------------
/src/ui/tutorials/fibonacci/program.ts:
--------------------------------------------------------------------------------
  1 | const FIBONACCI_PROGRAM = JSON.stringify(
  2 |   {
  3 |     attributes: [],
  4 |     builtins: [],
  5 |     compiler_version: "0.13.1",
  6 |     data: [
  7 |       "0x482680017ffd8000",
  8 |       "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff",
  9 |       "0x480680017fff8000",
 10 |       "0x1",
 11 |       "0x480680017fff8000",
 12 |       "0x1",
 13 |       "0x482480017ffd8000",
 14 |       "0x800000000000011000000000000000000000000000000000000000000000000",
 15 |       "0x48127ffe7fff8000",
 16 |       "0x48307ffd7ffc8000",
 17 |       "0x20680017fff7ffd",
 18 |       "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffd",
 19 |       "0x208b7fff7fff7ffe",
 20 |       "0x480680017fff8000",
 21 |       "0x4",
 22 |       "0x1104800180018000",
 23 |       "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff2",
 24 |       "0x208b7fff7fff7ffe",
 25 |     ],
 26 |     debug_info: {
 27 |       file_contents: {},
 28 |       instruction_locations: {
 29 |         "0": {
 30 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
 31 |           flow_tracking_data: {
 32 |             ap_tracking: {
 33 |               group: 0,
 34 |               offset: 0,
 35 |             },
 36 |             reference_ids: {
 37 |               "fibonacci.fibonacci.n": 0,
 38 |             },
 39 |           },
 40 |           hints: [],
 41 |           inst: {
 42 |             end_col: 22,
 43 |             end_line: 2,
 44 |             input_file: {
 45 |               filename:
 46 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
 47 |             },
 48 |             start_col: 17,
 49 |             start_line: 2,
 50 |           },
 51 |         },
 52 |         "2": {
 53 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
 54 |           flow_tracking_data: {
 55 |             ap_tracking: {
 56 |               group: 0,
 57 |               offset: 1,
 58 |             },
 59 |             reference_ids: {
 60 |               "fibonacci.fibonacci.n": 1,
 61 |             },
 62 |           },
 63 |           hints: [],
 64 |           inst: {
 65 |             end_col: 18,
 66 |             end_line: 3,
 67 |             input_file: {
 68 |               filename:
 69 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
 70 |             },
 71 |             start_col: 17,
 72 |             start_line: 3,
 73 |           },
 74 |         },
 75 |         "4": {
 76 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
 77 |           flow_tracking_data: {
 78 |             ap_tracking: {
 79 |               group: 0,
 80 |               offset: 2,
 81 |             },
 82 |             reference_ids: {
 83 |               "fibonacci.fibonacci.i": 2,
 84 |               "fibonacci.fibonacci.n": 1,
 85 |             },
 86 |           },
 87 |           hints: [],
 88 |           inst: {
 89 |             end_col: 18,
 90 |             end_line: 4,
 91 |             input_file: {
 92 |               filename:
 93 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
 94 |             },
 95 |             start_col: 17,
 96 |             start_line: 4,
 97 |           },
 98 |         },
 99 |         "6": {
100 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
101 |           flow_tracking_data: {
102 |             ap_tracking: {
103 |               group: 0,
104 |               offset: 3,
105 |             },
106 |             reference_ids: {
107 |               "fibonacci.fibonacci.i": 5,
108 |               "fibonacci.fibonacci.j": 6,
109 |               "fibonacci.fibonacci.n": 4,
110 |               "fibonacci.fibonacci.next": 7,
111 |             },
112 |           },
113 |           hints: [],
114 |           inst: {
115 |             end_col: 22,
116 |             end_line: 12,
117 |             input_file: {
118 |               filename:
119 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
120 |             },
121 |             start_col: 17,
122 |             start_line: 12,
123 |           },
124 |         },
125 |         "8": {
126 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
127 |           flow_tracking_data: {
128 |             ap_tracking: {
129 |               group: 0,
130 |               offset: 4,
131 |             },
132 |             reference_ids: {
133 |               "fibonacci.fibonacci.i": 5,
134 |               "fibonacci.fibonacci.j": 6,
135 |               "fibonacci.fibonacci.n": 8,
136 |               "fibonacci.fibonacci.next": 7,
137 |             },
138 |           },
139 |           hints: [],
140 |           inst: {
141 |             end_col: 21,
142 |             end_line: 9,
143 |             input_file: {
144 |               filename:
145 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
146 |             },
147 |             parent_location: [
148 |               {
149 |                 end_col: 18,
150 |                 end_line: 13,
151 |                 input_file: {
152 |                   filename:
153 |                     "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
154 |                 },
155 |                 start_col: 17,
156 |                 start_line: 13,
157 |               },
158 |               "While expanding the reference 'j' in:",
159 |             ],
160 |             start_col: 13,
161 |             start_line: 9,
162 |           },
163 |         },
164 |         "9": {
165 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
166 |           flow_tracking_data: {
167 |             ap_tracking: {
168 |               group: 0,
169 |               offset: 5,
170 |             },
171 |             reference_ids: {
172 |               "fibonacci.fibonacci.i": 9,
173 |               "fibonacci.fibonacci.j": 6,
174 |               "fibonacci.fibonacci.n": 8,
175 |               "fibonacci.fibonacci.next": 7,
176 |             },
177 |           },
178 |           hints: [],
179 |           inst: {
180 |             end_col: 21,
181 |             end_line: 10,
182 |             input_file: {
183 |               filename:
184 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
185 |             },
186 |             parent_location: [
187 |               {
188 |                 end_col: 21,
189 |                 end_line: 14,
190 |                 input_file: {
191 |                   filename:
192 |                     "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
193 |                 },
194 |                 start_col: 17,
195 |                 start_line: 14,
196 |               },
197 |               "While expanding the reference 'next' in:",
198 |             ],
199 |             start_col: 16,
200 |             start_line: 10,
201 |           },
202 |         },
203 |         "10": {
204 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
205 |           flow_tracking_data: {
206 |             ap_tracking: {
207 |               group: 0,
208 |               offset: 6,
209 |             },
210 |             reference_ids: {
211 |               "fibonacci.fibonacci.i": 9,
212 |               "fibonacci.fibonacci.j": 10,
213 |               "fibonacci.fibonacci.n": 8,
214 |               "fibonacci.fibonacci.next": 7,
215 |             },
216 |           },
217 |           hints: [],
218 |           inst: {
219 |             end_col: 23,
220 |             end_line: 20,
221 |             input_file: {
222 |               filename:
223 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
224 |             },
225 |             start_col: 5,
226 |             start_line: 20,
227 |           },
228 |         },
229 |         "12": {
230 |           accessible_scopes: ["fibonacci", "fibonacci.fibonacci"],
231 |           flow_tracking_data: {
232 |             ap_tracking: {
233 |               group: 0,
234 |               offset: 6,
235 |             },
236 |             reference_ids: {
237 |               "fibonacci.fibonacci.i": 12,
238 |               "fibonacci.fibonacci.j": 13,
239 |               "fibonacci.fibonacci.n": 11,
240 |               "fibonacci.fibonacci.next": 7,
241 |             },
242 |           },
243 |           hints: [],
244 |           inst: {
245 |             end_col: 14,
246 |             end_line: 27,
247 |             input_file: {
248 |               filename:
249 |                 "/home/antoine/Documents/cairo-vm-gs/cairo0/fibonacci.cairo",
250 |             },
251 |             start_col: 5,
252 |             start_line: 27,
253 |           },
254 |         },
255 |         "13": {
256 |           accessible_scopes: ["__main__", "__main__.main"],
257 |           flow_tracking_data: {
258 |             ap_tracking: {
259 |               group: 1,
260 |               offset: 0,
261 |             },
262 |             reference_ids: {},
263 |           },
264 |           hints: [],
265 |           inst: {
266 |             end_col: 16,
267 |             end_line: 4,
268 |             input_file: {
269 |               filename: "../../cairo0-test/fibonacci/main.cairo",
270 |             },
271 |             start_col: 15,
272 |             start_line: 4,
273 |           },
274 |         },
275 |         "15": {
276 |           accessible_scopes: ["__main__", "__main__.main"],
277 |           flow_tracking_data: {
278 |             ap_tracking: {
279 |               group: 1,
280 |               offset: 1,
281 |             },
282 |             reference_ids: {},
283 |           },
284 |           hints: [],
285 |           inst: {
286 |             end_col: 17,
287 |             end_line: 4,
288 |             input_file: {
289 |               filename: "../../cairo0-test/fibonacci/main.cairo",
290 |             },
291 |             start_col: 5,
292 |             start_line: 4,
293 |           },
294 |         },
295 |         "17": {
296 |           accessible_scopes: ["__main__", "__main__.main"],
297 |           flow_tracking_data: {
298 |             ap_tracking: {
299 |               group: 2,
300 |               offset: 0,
301 |             },
302 |             reference_ids: {},
303 |           },
304 |           hints: [],
305 |           inst: {
306 |             end_col: 15,
307 |             end_line: 5,
308 |             input_file: {
309 |               filename: "../../cairo0-test/fibonacci/main.cairo",
310 |             },
311 |             start_col: 5,
312 |             start_line: 5,
313 |           },
314 |         },
315 |       },
316 |     },
317 |     hints: {},
318 |     identifiers: {
319 |       "__main__.fibonacci": {
320 |         destination: "fibonacci.fibonacci",
321 |         type: "alias",
322 |       },
323 |       "__main__.main": {
324 |         decorators: [],
325 |         pc: 13,
326 |         type: "function",
327 |       },
328 |       "__main__.main.Args": {
329 |         full_name: "__main__.main.Args",
330 |         members: {},
331 |         size: 0,
332 |         type: "struct",
333 |       },
334 |       "__main__.main.ImplicitArgs": {
335 |         full_name: "__main__.main.ImplicitArgs",
336 |         members: {},
337 |         size: 0,
338 |         type: "struct",
339 |       },
340 |       "__main__.main.Return": {
341 |         cairo_type: "()",
342 |         type: "type_definition",
343 |       },
344 |       "__main__.main.SIZEOF_LOCALS": {
345 |         type: "const",
346 |         value: 0,
347 |       },
348 |       "fibonacci.fibonacci": {
349 |         decorators: [],
350 |         pc: 0,
351 |         type: "function",
352 |       },
353 |       "fibonacci.fibonacci.Args": {
354 |         full_name: "fibonacci.fibonacci.Args",
355 |         members: {
356 |           n: {
357 |             cairo_type: "felt",
358 |             offset: 0,
359 |           },
360 |         },
361 |         size: 1,
362 |         type: "struct",
363 |       },
364 |       "fibonacci.fibonacci.ImplicitArgs": {
365 |         full_name: "fibonacci.fibonacci.ImplicitArgs",
366 |         members: {},
367 |         size: 0,
368 |         type: "struct",
369 |       },
370 |       "fibonacci.fibonacci.Return": {
371 |         cairo_type: "felt",
372 |         type: "type_definition",
373 |       },
374 |       "fibonacci.fibonacci.SIZEOF_LOCALS": {
375 |         type: "const",
376 |         value: 0,
377 |       },
378 |       "fibonacci.fibonacci.body": {
379 |         pc: 6,
380 |         type: "label",
381 |       },
382 |       "fibonacci.fibonacci.end": {
383 |         pc: 12,
384 |         type: "label",
385 |       },
386 |       "fibonacci.fibonacci.i": {
387 |         cairo_type: "felt",
388 |         full_name: "fibonacci.fibonacci.i",
389 |         references: [
390 |           {
391 |             ap_tracking_data: {
392 |               group: 0,
393 |               offset: 2,
394 |             },
395 |             pc: 4,
396 |             value: "[cast(ap + (-1), felt*)]",
397 |           },
398 |           {
399 |             ap_tracking_data: {
400 |               group: 0,
401 |               offset: 3,
402 |             },
403 |             pc: 6,
404 |             value: "[cast(ap + (-2), felt*)]",
405 |           },
406 |           {
407 |             ap_tracking_data: {
408 |               group: 0,
409 |               offset: 5,
410 |             },
411 |             pc: 9,
412 |             value: "[cast(ap + (-1), felt*)]",
413 |           },
414 |           {
415 |             ap_tracking_data: {
416 |               group: 0,
417 |               offset: 6,
418 |             },
419 |             pc: 12,
420 |             value: "[cast(ap + (-2), felt*)]",
421 |           },
422 |         ],
423 |         type: "reference",
424 |       },
425 |       "fibonacci.fibonacci.j": {
426 |         cairo_type: "felt",
427 |         full_name: "fibonacci.fibonacci.j",
428 |         references: [
429 |           {
430 |             ap_tracking_data: {
431 |               group: 0,
432 |               offset: 3,
433 |             },
434 |             pc: 6,
435 |             value: "[cast(ap + (-1), felt*)]",
436 |           },
437 |           {
438 |             ap_tracking_data: {
439 |               group: 0,
440 |               offset: 3,
441 |             },
442 |             pc: 6,
443 |             value: "[cast(ap + (-1), felt*)]",
444 |           },
445 |           {
446 |             ap_tracking_data: {
447 |               group: 0,
448 |               offset: 6,
449 |             },
450 |             pc: 10,
451 |             value: "[cast(ap + (-1), felt*)]",
452 |           },
453 |           {
454 |             ap_tracking_data: {
455 |               group: 0,
456 |               offset: 6,
457 |             },
458 |             pc: 12,
459 |             value: "[cast(ap + (-1), felt*)]",
460 |           },
461 |         ],
462 |         type: "reference",
463 |       },
464 |       "fibonacci.fibonacci.n": {
465 |         cairo_type: "felt",
466 |         full_name: "fibonacci.fibonacci.n",
467 |         references: [
468 |           {
469 |             ap_tracking_data: {
470 |               group: 0,
471 |               offset: 0,
472 |             },
473 |             pc: 0,
474 |             value: "[cast(fp + (-3), felt*)]",
475 |           },
476 |           {
477 |             ap_tracking_data: {
478 |               group: 0,
479 |               offset: 1,
480 |             },
481 |             pc: 2,
482 |             value: "[cast(ap + (-1), felt*)]",
483 |           },
484 |           {
485 |             ap_tracking_data: {
486 |               group: 0,
487 |               offset: 3,
488 |             },
489 |             pc: 6,
490 |             value: "[cast(ap + (-3), felt*)]",
491 |           },
492 |           {
493 |             ap_tracking_data: {
494 |               group: 0,
495 |               offset: 4,
496 |             },
497 |             pc: 8,
498 |             value: "[cast(ap + (-1), felt*)]",
499 |           },
500 |           {
501 |             ap_tracking_data: {
502 |               group: 0,
503 |               offset: 6,
504 |             },
505 |             pc: 12,
506 |             value: "[cast(ap + (-3), felt*)]",
507 |           },
508 |         ],
509 |         type: "reference",
510 |       },
511 |       "fibonacci.fibonacci.next": {
512 |         cairo_type: "felt",
513 |         full_name: "fibonacci.fibonacci.next",
514 |         references: [
515 |           {
516 |             ap_tracking_data: {
517 |               group: 0,
518 |               offset: 3,
519 |             },
520 |             pc: 6,
521 |             value: "cast([ap + (-2)] + [ap + (-1)], felt)",
522 |           },
523 |         ],
524 |         type: "reference",
525 |       },
526 |     },
527 |     main_scope: "__main__",
528 |     prime: "0x800000000000011000000000000000000000000000000000000000000000001",
529 |     reference_manager: {
530 |       references: [
531 |         {
532 |           ap_tracking_data: {
533 |             group: 0,
534 |             offset: 0,
535 |           },
536 |           pc: 0,
537 |           value: "[cast(fp + (-3), felt*)]",
538 |         },
539 |         {
540 |           ap_tracking_data: {
541 |             group: 0,
542 |             offset: 1,
543 |           },
544 |           pc: 2,
545 |           value: "[cast(ap + (-1), felt*)]",
546 |         },
547 |         {
548 |           ap_tracking_data: {
549 |             group: 0,
550 |             offset: 2,
551 |           },
552 |           pc: 4,
553 |           value: "[cast(ap + (-1), felt*)]",
554 |         },
555 |         {
556 |           ap_tracking_data: {
557 |             group: 0,
558 |             offset: 3,
559 |           },
560 |           pc: 6,
561 |           value: "[cast(ap + (-1), felt*)]",
562 |         },
563 |         {
564 |           ap_tracking_data: {
565 |             group: 0,
566 |             offset: 3,
567 |           },
568 |           pc: 6,
569 |           value: "[cast(ap + (-3), felt*)]",
570 |         },
571 |         {
572 |           ap_tracking_data: {
573 |             group: 0,
574 |             offset: 3,
575 |           },
576 |           pc: 6,
577 |           value: "[cast(ap + (-2), felt*)]",
578 |         },
579 |         {
580 |           ap_tracking_data: {
581 |             group: 0,
582 |             offset: 3,
583 |           },
584 |           pc: 6,
585 |           value: "[cast(ap + (-1), felt*)]",
586 |         },
587 |         {
588 |           ap_tracking_data: {
589 |             group: 0,
590 |             offset: 3,
591 |           },
592 |           pc: 6,
593 |           value: "cast([ap + (-2)] + [ap + (-1)], felt)",
594 |         },
595 |         {
596 |           ap_tracking_data: {
597 |             group: 0,
598 |             offset: 4,
599 |           },
600 |           pc: 8,
601 |           value: "[cast(ap + (-1), felt*)]",
602 |         },
603 |         {
604 |           ap_tracking_data: {
605 |             group: 0,
606 |             offset: 5,
607 |           },
608 |           pc: 9,
609 |           value: "[cast(ap + (-1), felt*)]",
610 |         },
611 |         {
612 |           ap_tracking_data: {
613 |             group: 0,
614 |             offset: 6,
615 |           },
616 |           pc: 10,
617 |           value: "[cast(ap + (-1), felt*)]",
618 |         },
619 |         {
620 |           ap_tracking_data: {
621 |             group: 0,
622 |             offset: 6,
623 |           },
624 |           pc: 12,
625 |           value: "[cast(ap + (-3), felt*)]",
626 |         },
627 |         {
628 |           ap_tracking_data: {
629 |             group: 0,
630 |             offset: 6,
631 |           },
632 |           pc: 12,
633 |           value: "[cast(ap + (-2), felt*)]",
634 |         },
635 |         {
636 |           ap_tracking_data: {
637 |             group: 0,
638 |             offset: 6,
639 |           },
640 |           pc: 12,
641 |           value: "[cast(ap + (-1), felt*)]",
642 |         },
643 |       ],
644 |     },
645 |   },
646 |   null,
647 |   2,
648 | );
649 | 


--------------------------------------------------------------------------------
/src/ui/tutorials/fibonacci/steps.ts:
--------------------------------------------------------------------------------
 1 | const FIBONACCI: string = "Fibonacci";
 2 | 
 3 | function startFibonacci() {
 4 |   loadProgram(FIBONACCI_PROGRAM, "Execution", "plain");
 5 |   startTutorial(FIBONACCI);
 6 |   addNotesFibonacci();
 7 | }
 8 | 
 9 | function addNotesFibonacci() {
10 |   addNotes(FIBONACCI);
11 | }
12 | 
13 | const stepsFibonacci: Step[] = [
14 |   {
15 |     cell: "A1",
16 |     sheetName: "Run",
17 |     message:
18 |       "This is the starting point of the Fibonacci tutorial. Go to the next step to execute the fibonacci program on the GS CairoVM !",
19 |     action: () => SpreadsheetApp.getActiveSpreadsheet().toast("Hey !"),
20 |   },
21 |   {
22 |     cell: "A1",
23 |     sheetName: "Run",
24 |     message: "The script is running...",
25 |     action: menuRun,
26 |   },
27 |   {
28 |     cell: "C3",
29 |     sheetName: "Program",
30 |     message: "There we go.",
31 |   },
32 | ];
33 | 


--------------------------------------------------------------------------------
/src/ui/tutorials/tutorials.ts:
--------------------------------------------------------------------------------
  1 | interface Step {
  2 |   cell: string;
  3 |   sheetName: string;
  4 |   message: string;
  5 |   action?: () => void;
  6 | }
  7 | 
  8 | const steps = {
  9 |   Fibonacci: stepsFibonacci,
 10 | };
 11 | 
 12 | function startTutorial(tutorialName: string) {
 13 |   clearNotes();
 14 | 
 15 |   const ui = SpreadsheetApp.getUi();
 16 | 
 17 |   const response = ui.alert(
 18 |     `${tutorialName} Tutorial`,
 19 |     `Welcome to the ${tutorialName} tutorial!
 20 |         \nThis tutorial consists of cell annotations being shown to you so that you get a better understanding of the CairoVM.
 21 |         \nThe cell associated to a step of the tutorial has a yellow background and you can see its annotation by hovering the cell.
 22 |         \nOnce you are done with reading the note, go in the "Tutorial" menu and click "Next".
 23 |         \nClick "Ok" to begin.`,
 24 |     ui.ButtonSet.OK,
 25 |   );
 26 | 
 27 |   if (response === ui.Button.OK) {
 28 |     const offset: number = Object.keys(steps).includes(getTutorialName())
 29 |       ? -1
 30 |       : 0;
 31 |     programSheet
 32 |       .getRange(programSheet.getLastRow() + 1 + offset, 2)
 33 |       .setValue(0);
 34 |     programSheet.getRange(programSheet.getLastRow(), 1).setValue(tutorialName);
 35 |     doStepTuto(0, tutorialName);
 36 |   }
 37 | }
 38 | 
 39 | function doStepTuto(stepIndex: number, tutorialName: string) {
 40 |   const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
 41 | 
 42 |   //Clear previous step background
 43 |   const previousStepIndex = stepIndex == 0 ? 0 : stepIndex - 1;
 44 |   const previousStep = steps[tutorialName][previousStepIndex];
 45 |   const previousSheet = spreadsheet.getSheetByName(previousStep.sheetName);
 46 |   previousSheet.getRange(previousStep.cell).setBackground("white");
 47 | 
 48 |   //Set focus on step cell
 49 |   const currentStep = steps[tutorialName][stepIndex];
 50 |   const currentSheet = spreadsheet.getSheetByName(currentStep.sheetName);
 51 | 
 52 |   const range = currentSheet.getRange(currentStep.cell);
 53 |   range.setBackground("yellow");
 54 |   currentSheet.activate();
 55 |   currentSheet.setActiveRange(range);
 56 | 
 57 |   //Execute action related to step
 58 |   if (currentStep.action) {
 59 |     currentStep.action();
 60 |   }
 61 | }
 62 | 
 63 | function nextStepTuto() {
 64 |   const previousStepIndex = getStepIndex();
 65 |   const tutorialName: string = getTutorialName();
 66 | 
 67 |   if (previousStepIndex < steps[tutorialName].length - 1) {
 68 |     doStepTuto(previousStepIndex + 1, tutorialName);
 69 |     programSheet
 70 |       .getRange(programSheet.getLastRow(), 2)
 71 |       .setValue(previousStepIndex + 1);
 72 |   } else {
 73 |     const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
 74 |     const previousStep = steps[tutorialName][previousStepIndex];
 75 |     const previousSheet = spreadsheet.getSheetByName(previousStep.sheetName);
 76 |     previousSheet.getRange(previousStep.cell).setBackground("white");
 77 | 
 78 |     SpreadsheetApp.getUi().alert(
 79 |       `You have completed the ${tutorialName} tutorial!`,
 80 |     );
 81 |   }
 82 | }
 83 | 
 84 | function clearNotes() {
 85 |   const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
 86 |   const sheets = spreadsheet.getSheets();
 87 | 
 88 |   sheets.forEach((sheet) => {
 89 |     const range = sheet.getDataRange(); // Get the range of all data in the sheet
 90 |     range.clearNote(); // Clear all notes in the range
 91 |   });
 92 | }
 93 | 
 94 | function addNotes(tutorialName: string) {
 95 |   const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
 96 | 
 97 |   steps[tutorialName].forEach((step: Step) => {
 98 |     const sheet = spreadsheet.getSheetByName(step.sheetName);
 99 |     const range = sheet.getRange(step.cell);
100 |     range.setNote(step.message);
101 |   });
102 | }
103 | 
104 | function getTutorialName(): string {
105 |   return String(programSheet.getRange(programSheet.getLastRow(), 1).getValue());
106 | }
107 | 
108 | function getStepIndex(): number {
109 |   return Number(programSheet.getRange(programSheet.getLastRow(), 2).getValue());
110 | }
111 | 


--------------------------------------------------------------------------------
/src/ui/ui.ts:
--------------------------------------------------------------------------------
  1 | function onOpen(): void {
  2 |   var ui: GoogleAppsScript.Base.Ui = SpreadsheetApp.getUi();
  3 |   ui.createMenu("Cairo VM")
  4 |     .addItem("Step", "menuStep")
  5 |     .addItem("Run", "menuRun")
  6 |     .addItem("Clear", "clear")
  7 |     .addItem("Load Program", "showPicker")
  8 |     .addItem("Relocate", "relocate")
  9 |     .addToUi();
 10 | 
 11 |   ui.createMenu("Tutorials")
 12 |     .addItem("Fibonacci - add notes", "addNotesFibonacci")
 13 |     .addItem("Fibonacci - start tutorial", "startFibonacci")
 14 |     .addItem("Next", "nextStepTuto")
 15 |     .addItem("Clear notes", "clearNotes")
 16 |     .addToUi();
 17 | }
 18 | 
 19 | function menuStep(): void {
 20 |   step(getLastActiveRowNumber(`${pcColumn}`, runSheet) - 2);
 21 | }
 22 | 
 23 | function menuRun(): void {
 24 |   let lastStepNumber: number = runUntilPc();
 25 |   if (isProofMode()) {
 26 |     step(lastStepNumber - 1);
 27 |     step(lastStepNumber - 1 + 1);
 28 |     let lastRegisters = runSheet
 29 |       .getRange(
 30 |         `${pcColumn}${lastStepNumber + 1}:${apColumn}${lastStepNumber + 1}`,
 31 |       )
 32 |       .getValues();
 33 |     let firstOfLoopRegister = runSheet
 34 |       .getRange(
 35 |         `${pcColumn}${lastStepNumber + 2}:${apColumn}${lastStepNumber + 2}`,
 36 |       )
 37 |       .getValues();
 38 |     if (
 39 |       Number(lastRegisters[0][0]) != Number(firstOfLoopRegister[0][0]) &&
 40 |       Number(lastRegisters[0][1]) != Number(firstOfLoopRegister[0][1]) &&
 41 |       Number(lastRegisters[0][2]) != Number(firstOfLoopRegister[0][2])
 42 |     ) {
 43 |       Logger.log("Make sure the program is compiled and loaded in proof mode.");
 44 |       throw new InvalidLoopRegisters();
 45 |     }
 46 |     for (
 47 |       let stepNum = lastStepNumber + 3;
 48 |       stepNum <= nextPowerOfTwo(lastStepNumber) + 1;
 49 |       stepNum++
 50 |     ) {
 51 |       step(stepNum - 2);
 52 |     }
 53 | 
 54 |     //Clear new registers for proper relocation purposes
 55 |     let registerRowToClear: number = nextPowerOfTwo(lastStepNumber) + 2;
 56 |     runSheet
 57 |       .getRange(
 58 |         `${pcColumn}${registerRowToClear}:${apColumn}${registerRowToClear}`,
 59 |       )
 60 |       .clearContent();
 61 |   }
 62 | }
 63 | 
 64 | function clear(): void {
 65 |   const stackLength: number = Number(
 66 |     runSheet.getRange(`${apColumn}2`).getValue(),
 67 |   );
 68 |   runSheet.getRange(`${pcColumn}3:${apColumn}`).clearContent();
 69 |   runSheet.getRange(`${opcodeColumn}2:${runOp1Column}`).clearContent();
 70 |   runSheet
 71 |     .getRange(`${executionColumn}${stackLength + 2}:${executionColumn}`)
 72 |     .clearContent();
 73 |   runSheet
 74 |     .getRange(
 75 |       `${firstBuiltinColumn}2:${indexToColumn(columnToIndex(firstBuiltinColumn) + stackLength + 2)}`,
 76 |     )
 77 |     .clearContent();
 78 |   proverSheet
 79 |     .getRange(
 80 |       `${provSegmentsColumn}3:${indexToColumn(getLastActiveColumnNumber(2, proverSheet) - 1)}`,
 81 |     )
 82 |     .clearContent();
 83 | }
 84 | 
 85 | function showPicker() {
 86 |   try {
 87 |     const html = HtmlService.createHtmlOutputFromFile("src/ui/dialog.html")
 88 |       .setWidth(800)
 89 |       .setHeight(600)
 90 |       .setSandboxMode(HtmlService.SandboxMode.IFRAME);
 91 |     SpreadsheetApp.getUi().showModalDialog(html, "Select a file");
 92 |   } catch (e) {
 93 |     // TODO (Developer) - Handle exception
 94 |     console.log("Failed with error: %s", e.error);
 95 |   }
 96 | }
 97 | 
 98 | var cache = CacheService.getScriptCache();
 99 | 
100 | function updateCacheProgress(current: string) {
101 |   cache.put("current", current, 10); // Cache for 10 seconds
102 | }
103 | 
104 | function getProgress() {
105 |   const current = cache.get("current");
106 |   return { current: current || "" };
107 | }
108 | 
109 | function loadProgram(
110 |   programStringified: any,
111 |   selectedRunnerMode: string,
112 |   selectedLayout: string,
113 | ) {
114 |   updateCacheProgress("Parsing program...");
115 |   let program = JSON.parse(programStringified);
116 |   let isProofMode: boolean = selectedRunnerMode === "proof";
117 |   let layout: Layout = layouts[selectedLayout];
118 | 
119 |   updateCacheProgress("Clearing prover sheet...");
120 |   proverSheet
121 |     .getRange(
122 |       `${provSegmentsColumn}3:${indexToColumn(getLastActiveColumnNumber(2, proverSheet) - 1)}`,
123 |     )
124 |     .clearContent();
125 | 
126 |   updateCacheProgress("Clearing program sheet...");
127 |   programSheet
128 |     .getRange(
129 |       `${progBytecodeColumn}2:${indexToColumn(getLastActiveColumnNumber(1, programSheet) - 1)}`,
130 |     )
131 |     .clearContent();
132 | 
133 |   updateCacheProgress("Decoding instruction and flags...");
134 |   programSheet
135 |     .getRange(`${progDecInstructionColumn}1`)
136 |     .setValue("Decimal instruction");
137 |   programSheet
138 |     .getRange(`${progDstOffsetColumn}1:${progOp1OffsetColumn}1`)
139 |     .setValues([["Dst Offset", "Op0 Offset", "Op1 Offset"]]);
140 | 
141 |   for (let flagIndex = 0; flagIndex < 16; flagIndex++) {
142 |     programSheet
143 |       .getRange(
144 |         `${indexToColumn(columnToIndex(progOp1OffsetColumn) + flagIndex + 1)}1`,
145 |       )
146 |       .setValue(`f_${flagIndex}`);
147 |   }
148 | 
149 |   const bytecode: string[] = program.data;
150 |   let isConstant: boolean = false;
151 |   for (var i = 0; i < bytecode.length; i++) {
152 |     programSheet
153 |       .getRange(`${progBytecodeColumn}${i + 2}:${progOpcodeColumn}${i + 2}`)
154 |       .setValues([
155 |         [
156 |           bytecode[i],
157 |           isConstant
158 |             ? `=TO_SIGNED_INTEGER(${progBytecodeColumn}${i + 2})`
159 |             : `=DECODE_INSTRUCTION(${progBytecodeColumn}${i + 2})`,
160 |         ],
161 |       ]);
162 |     programSheet
163 |       .getRange(`${progDstOffsetColumn}${i + 2}`)
164 |       .setFormula(`=GET_FLAGS_AND_OFFSETS(${progBytecodeColumn}${i + 2})`);
165 |     programSheet
166 |       .getRange(`${progDecInstructionColumn}${i + 2}`)
167 |       .setValue(BigInt(bytecode[i]).toString(10));
168 |     if (!isConstant) {
169 |       isConstant = size(decodeInstruction(BigInt(bytecode[i]))) == 2;
170 |     } else {
171 |       isConstant = false;
172 |     }
173 |   }
174 | 
175 |   //Store complementary data (builtins, initial and final pc, proofMode, layout)
176 |   //to avoid loosing it when reloading the page for instance.
177 |   updateCacheProgress("Storing complementary data...");
178 |   let lastActiveRowProgram: number = getLastActiveRowNumber(
179 |     progBytecodeColumn,
180 |     programSheet,
181 |   );
182 |   let rowOffset: number = lastActiveRowProgram + 3; //3 offset is arbitrary
183 |   programSheet.getRange(rowOffset, 1).setValue("Complementary information");
184 |   //programSheet.getRange(rowOffset,1,rowOffset,2).mergeAcross();
185 |   rowOffset++;
186 |   programSheet.getRange(rowOffset, 1).setValue("proof_mode");
187 |   programSheet.getRange(rowOffset, 2).setValue(isProofMode ? 1 : 0);
188 |   rowOffset++;
189 |   programSheet.getRange(rowOffset, 1).setValue("used_builtins");
190 |   if (program.builtins.length > 0) {
191 |     programSheet
192 |       .getRange(rowOffset, 2, program.builtins.length)
193 |       .setValues(program.builtins.map((builtin) => [builtin]));
194 |     rowOffset += program.builtins.length;
195 |   } else {
196 |     rowOffset += 1;
197 |   }
198 |   programSheet.getRange(rowOffset, 1).setValue("initial_pc");
199 |   programSheet
200 |     .getRange(rowOffset, 2)
201 |     .setValue(
202 |       `Program!A${program["identifiers"][`__main__.${isProofMode ? "__start__" : "main"}`]["pc"] + 2}`,
203 |     );
204 |   rowOffset++;
205 |   programSheet.getRange(rowOffset, 1).setValue(FINAL_PC);
206 |   rowOffset++;
207 |   programSheet.getRange(rowOffset, 1).setValue("initial_ap");
208 |   rowOffset++;
209 |   programSheet.getRange(rowOffset, 1).setValue("layout");
210 |   programSheet.getRange(rowOffset, 2).setValue(selectedLayout);
211 |   rowOffset++;
212 | 
213 |   //Run sheet
214 |   updateCacheProgress("Initializing run sheet...");
215 |   runSheet
216 |     .getRange(
217 |       `${pcColumn}1:${indexToColumn(getLastActiveColumnNumber(1, runSheet) - 1)}`,
218 |     )
219 |     .clearContent();
220 |   runSheet
221 |     .getRange(`${pcColumn}1:${executionColumn}1`)
222 |     .setValues([
223 |       ["PC", "FP", "AP", "Opcode", "Dst", "Res", "Op0", "Op1", "Execution"],
224 |     ]);
225 | 
226 |   initializeProgram(program, isProofMode, layout);
227 | }
228 | 
229 | function relocate() {
230 |   let lastLastActiveColumnIndex: number =
231 |     getLastActiveColumnNumber(2, proverSheet) - 1;
232 |   proverSheet
233 |     .getRange(
234 |       `${provSegmentsColumn}3:${indexToColumn(lastLastActiveColumnIndex == -1 ? 0 : lastLastActiveColumnIndex)}`,
235 |     )
236 |     .clearContent();
237 | 
238 |   proverSheet.getRange(`${provSegmentsColumn}1`).setValue("Memory");
239 |   proverSheet
240 |     .getRange(`${provSegmentsColumn}1:${provMemoryRelocatedColumn}1`)
241 |     .mergeAcross();
242 | 
243 |   proverSheet.getRange(`${provRelocatedPcColumn}1`).setValue("Relocated Trace");
244 |   proverSheet
245 |     .getRange(`${provRelocatedPcColumn}1:${provRelocatedApColumn}1`)
246 |     .mergeAcross();
247 | 
248 |   proverSheet
249 |     .getRange(`${provSegmentsColumn}2:${provRelocatedApColumn}2`)
250 |     .setValues([
251 |       ["Segments", "Addresses", "Values", "Relocated", "PC", "FP", "AP"],
252 |     ]);
253 | 
254 |   relocateMemory();
255 |   relocateTrace();
256 | }
257 | 


--------------------------------------------------------------------------------
/src/utils.ts:
--------------------------------------------------------------------------------
  1 | function objectFromEntries(keys: any, values: any): any {
  2 |   return keys.reduce(
  3 |     (prev, key, index) => ({ ...prev, [key]: values[index] }),
  4 |     {},
  5 |   );
  6 | }
  7 | 
  8 | function getLastActiveRowNumber(column: string, sheet): number {
  9 |   let columnValues: string[] = sheet
 10 |     .getRange(`${column}1:${column}`)
 11 |     .getValues()
 12 |     .map((element) => {
 13 |       return element && element.length > 0 ? element[0] : "";
 14 |     });
 15 |   let lastNonEmptyIndex = columnValues
 16 |     .slice()
 17 |     .reverse()
 18 |     .findIndex((value) => value !== "");
 19 |   if (lastNonEmptyIndex === -1) {
 20 |     return 0;
 21 |   }
 22 | 
 23 |   return columnValues.length - lastNonEmptyIndex;
 24 | }
 25 | 
 26 | function getLastActiveFormulaRowNumber(column: string, sheet): number {
 27 |   let columnValues: string[] = sheet
 28 |     .getRange(`${column}1:${column}`)
 29 |     .getFormulas()
 30 |     .map((element) => {
 31 |       return element && element.length > 0 ? element[0] : "";
 32 |     });
 33 |   let lastNonEmptyIndex = columnValues
 34 |     .slice()
 35 |     .reverse()
 36 |     .findIndex((value) => value !== "");
 37 |   if (lastNonEmptyIndex === -1) {
 38 |     return 0;
 39 |   }
 40 | 
 41 |   return columnValues.length - lastNonEmptyIndex;
 42 | }
 43 | 
 44 | function getLastActiveColumnNumber(row: number, sheet): number {
 45 |   let rowValues: string[] = sheet.getRange(`${row}1:${row}`).getValues()[0];
 46 | 
 47 |   let lastNonEmptyIndex = rowValues
 48 |     .slice()
 49 |     .reverse()
 50 |     .findIndex((value) => value !== "");
 51 | 
 52 |   if (lastNonEmptyIndex === -1) {
 53 |     return 0;
 54 |   }
 55 | 
 56 |   return rowValues.length - lastNonEmptyIndex;
 57 | }
 58 | 
 59 | function encodeUTF8(str: string): Uint8Array {
 60 |   const utf8Bytes: number[] = [];
 61 | 
 62 |   for (let i = 0; i < str.length; i++) {
 63 |     let charCode = str.charCodeAt(i);
 64 | 
 65 |     if (charCode < 0x80) {
 66 |       utf8Bytes.push(charCode);
 67 |     } else if (charCode < 0x800) {
 68 |       utf8Bytes.push(((charCode >> 6) & 0x1f) | 0xc0);
 69 |       utf8Bytes.push((charCode & 0x3f) | 0x80);
 70 |     } else {
 71 |       utf8Bytes.push(((charCode >> 12) & 0x0f) | 0xe0);
 72 |       utf8Bytes.push(((charCode >> 6) & 0x3f) | 0x80);
 73 |       utf8Bytes.push((charCode & 0x3f) | 0x80);
 74 |     }
 75 |   }
 76 | 
 77 |   return new Uint8Array(utf8Bytes);
 78 | }
 79 | 
 80 | function isCell(str: string): boolean {
 81 |   const regex = /^([A-Za-z]+[A-Za-z]*\d+|[A-Za-z]+)(\![A-Za-z]+\d+)?$/;
 82 |   return regex.test(str);
 83 | }
 84 | 
 85 | function getSheetName(cellReference: string): string {
 86 |   const parts = cellReference.split("!");
 87 |   return parts.length > 1 ? parts[0] : "";
 88 | }
 89 | 
 90 | function getFormulaOfAddition(
 91 |   value1: string,
 92 |   value2: string,
 93 |   address1: string,
 94 |   address2: string,
 95 | ): string {
 96 |   var formula: string;
 97 |   if (isCell(value1) && !isCell(value2)) {
 98 |     let columnValue1: string = indexToColumn(
 99 |       runSheet.getRange(value1).getColumn() - 1,
100 |     );
101 |     let rowValue1: number = runSheet.getRange(value1).getRow();
102 |     let sheetNamePrefix: string =
103 |       getSheetName(value1) == "" ? "" : getSheetName(value1) + "!";
104 |     formula = `="${sheetNamePrefix}${columnValue1}" & (${rowValue1} + ${address2})`;
105 |   }
106 |   if (!isCell(value1) && isCell(value2)) {
107 |     let columnValue2: string = indexToColumn(
108 |       runSheet.getRange(value2).getColumn() - 1,
109 |     );
110 |     let rowValue2: number = runSheet.getRange(value2).getRow();
111 |     let sheetNamePrefix: string =
112 |       getSheetName(value2) == "" ? "" : getSheetName(value2) + "!";
113 |     formula = `="${sheetNamePrefix}${columnValue2}" & (${rowValue2} + ${address1})`;
114 |   }
115 |   if (!isCell(value1) && !isCell(value2)) {
116 |     formula = `=${address1} + ${address2}`;
117 |   }
118 |   if (isCell(value1) && isCell(value2)) {
119 |     if (value1[0] !== value2[0]) {
120 |       throw new InvalidCellSumError();
121 |     }
122 |     let columnValue: string = indexToColumn(
123 |       runSheet.getRange(value1).getColumn() - 1,
124 |     );
125 |     let sheetNamePrefix: string =
126 |       getSheetName(value1) == "" ? "" : getSheetName(value1) + "!";
127 |     let rowValue1: number = runSheet.getRange(value1).getRow();
128 |     let rowValue2: number = runSheet.getRange(value2).getRow();
129 |     formula = `="${sheetNamePrefix}${columnValue}" & (${rowValue1} + ${rowValue2})`;
130 |   }
131 |   return formula;
132 | }
133 | 
134 | function addSegmentValues(
135 |   segmentValue1: string,
136 |   segmentValue2: string,
137 | ): string {
138 |   var sum: string;
139 |   if (isCell(segmentValue1) && !isCell(segmentValue2)) {
140 |     let columnValue1: string = indexToColumn(
141 |       runSheet.getRange(segmentValue1).getColumn() - 1,
142 |     );
143 |     let rowValue1: number = runSheet.getRange(segmentValue1).getRow();
144 |     let sheetNamePrefix: string =
145 |       getSheetName(segmentValue1) == ""
146 |         ? ""
147 |         : getSheetName(segmentValue1) + "!";
148 |     sum = `${sheetNamePrefix}${columnValue1}${rowValue1 + Number(segmentValue2)}`;
149 |   }
150 |   if (!isCell(segmentValue1) && isCell(segmentValue2)) {
151 |     let columnValue2: string = indexToColumn(
152 |       runSheet.getRange(segmentValue2).getColumn() - 1,
153 |     );
154 |     let rowValue2: number = runSheet.getRange(segmentValue2).getRow();
155 |     let sheetNamePrefix: string =
156 |       getSheetName(segmentValue2) == ""
157 |         ? ""
158 |         : getSheetName(segmentValue2) + "!";
159 |     sum = `${sheetNamePrefix}${columnValue2}${rowValue2 + Number(segmentValue1)}`;
160 |   }
161 |   if (!isCell(segmentValue1) && !isCell(segmentValue2)) {
162 |     sum = `${Number(segmentValue1) + Number(segmentValue2)}`;
163 |   }
164 |   if (isCell(segmentValue1) && isCell(segmentValue2)) {
165 |     if (segmentValue1[0] !== segmentValue2[0]) {
166 |       throw new InvalidCellSumError();
167 |     }
168 |     let columnValue: string = indexToColumn(
169 |       runSheet.getRange(segmentValue1).getColumn() - 1,
170 |     );
171 |     let sheetNamePrefix: string =
172 |       getSheetName(segmentValue1) == ""
173 |         ? ""
174 |         : getSheetName(segmentValue1) + "!";
175 |     let rowValue1: number = runSheet.getRange(segmentValue1).getRow();
176 |     let rowValue2: number = runSheet.getRange(segmentValue2).getRow();
177 |     sum = `${sheetNamePrefix}${columnValue}${rowValue1 + rowValue2}`;
178 |   }
179 |   return sum;
180 | }
181 | 
182 | function updateBuiltins() {
183 |   const startColumn = 8;
184 |   const lastColumn = runSheet.getLastColumn();
185 |   const range = runSheet.getRange(
186 |     1,
187 |     startColumn,
188 |     1,
189 |     lastColumn - startColumn + 1,
190 |   );
191 |   const values = range.getValues()[0];
192 | 
193 |   for (let i = 0; i < values.length; i++) {
194 |     if (builtins[values[i]]) {
195 |       builtins[values[i]].column = String.fromCharCode(startColumn + i + 64);
196 |     }
197 |   }
198 | }
199 | 
200 | function isFinalPc(pc: number | string): boolean {
201 |   return pc == programSheet.getRange(getFinalPcCell()).getValue();
202 | }
203 | 
204 | function bigintTo15BitString(value: bigint): string {
205 |   let binaryStr = value.toString(2);
206 | 
207 |   if (binaryStr.length > 15) {
208 |     binaryStr = binaryStr.slice(-15);
209 |   } else {
210 |     binaryStr = binaryStr.padStart(15, "0");
211 |   }
212 | 
213 |   return binaryStr;
214 | }
215 | 
216 | function indexToColumn(index: number): string {
217 |   let column = "";
218 |   index += 1;
219 |   while (index > 0) {
220 |     let remainder = (index - 1) % 26;
221 |     column = String.fromCharCode(65 + remainder) + column;
222 |     index = Math.floor((index - 1) / 26);
223 |   }
224 |   return column;
225 | }
226 | 
227 | function columnToIndex(column: string): number {
228 |   let rowNum = 0;
229 |   for (let i = 0; i < column.length; i++) {
230 |     rowNum *= 26;
231 |     rowNum += column.charCodeAt(i) - 64;
232 |   }
233 |   return rowNum - 1;
234 | }
235 | 
236 | function getFinalPcCell(): string {
237 |   return `B${
238 |     programSheet
239 |       .getRange("A1:A")
240 |       .getValues()
241 |       .map((value) => {
242 |         if (value) {
243 |           return value[0];
244 |         }
245 |       })
246 |       .indexOf(FINAL_PC) + 1
247 |   }`;
248 | }
249 | 
250 | function getProofModeCell(): string {
251 |   return `B${
252 |     programSheet
253 |       .getRange("A1:A")
254 |       .getValues()
255 |       .map((value) => {
256 |         if (value) {
257 |           return value[0];
258 |         }
259 |       })
260 |       .indexOf("proof_mode") + 1
261 |   }`;
262 | }
263 | 
264 | function isProofMode(): boolean {
265 |   return Number(programSheet.getRange(getProofModeCell()).getValue()) == 1;
266 | }
267 | 
268 | function nextPowerOfTwo(n: number): number {
269 |   return 1 << Math.ceil(Math.log2(n));
270 | }
271 | 
272 | function hasEmptyCell(array): boolean {
273 |   return array.flat().includes("");
274 | }
275 | 


--------------------------------------------------------------------------------
/src/vm/constants.ts:
--------------------------------------------------------------------------------
  1 | interface RegistersType {
  2 |   AP: string;
  3 |   FP: string;
  4 |   PC: string;
  5 | }
  6 | 
  7 | interface Op1SrcType {
  8 |   Op0: string;
  9 |   AP: string;
 10 |   FP: string;
 11 |   PC: string;
 12 | }
 13 | 
 14 | interface PCUpdatesType {
 15 |   Regular: string;
 16 |   Jump: string;
 17 |   JumpRel: string;
 18 |   Jnz: string;
 19 | }
 20 | 
 21 | interface ResLogicsType {
 22 |   Op1: string;
 23 |   Add: string;
 24 |   Mul: string;
 25 |   Unused: string;
 26 | }
 27 | 
 28 | interface OpcodesType {
 29 |   NOp: string;
 30 |   Call: string;
 31 |   Ret: string;
 32 |   AssertEq: string;
 33 | }
 34 | 
 35 | interface ApUpdatesType {
 36 |   Constant: string;
 37 |   AddRes: string;
 38 |   Add1: string;
 39 |   Add2: string;
 40 | }
 41 | 
 42 | interface FpUpdatesType {
 43 |   Constant: string;
 44 |   Dst: string;
 45 |   ApPlus2: string;
 46 | }
 47 | 
 48 | interface SignatureType {
 49 |   r: bigint;
 50 |   s: bigint;
 51 | }
 52 | 
 53 | interface HadesParamsType {
 54 |   r: number;
 55 |   c: number;
 56 |   m: number;
 57 |   Rf: number;
 58 |   Rp: number;
 59 |   nRounds: number;
 60 |   outputSize: number;
 61 |   ark: bigint[][];
 62 |   mds: bigint[][];
 63 | }
 64 | 
 65 | interface BuitlinType {
 66 |   freeCellsPerBuiltin: number;
 67 |   numOutputCells: number;
 68 |   column: string;
 69 |   functionName: string;
 70 | }
 71 | 
 72 | type Layout = {
 73 |   builtins: string[];
 74 | };
 75 | 
 76 | const PRIME: bigint = BigInt(
 77 |   "0x800000000000011000000000000000000000000000000000000000000000001",
 78 | );
 79 | 
 80 | const GENERATOR = new AffinePoint(
 81 |   "874739451078007766457464989774322083649278607533249481151382481072868806602",
 82 |   "152666792071518830868575557812948353041420400780739481342941381225525861407",
 83 | );
 84 | const ORDER = BigInt(
 85 |   "3618502788666131213697322783095070105526743751716087489154079457884512865583",
 86 | );
 87 | 
 88 | const ALPHA: bigint = BigInt(1);
 89 | 
 90 | const Registers: RegistersType = {
 91 |   AP: "AP",
 92 |   FP: "FP",
 93 |   PC: "PC",
 94 | };
 95 | 
 96 | const Op1Src: Op1SrcType = {
 97 |   Op0: "Op0",
 98 |   AP: "AP",
 99 |   FP: "FP",
100 |   PC: "PC",
101 | };
102 | 
103 | const PcUpdates: PCUpdatesType = {
104 |   Regular: "PC + instruction size",
105 |   Jump: "jmp abs",
106 |   JumpRel: "jmp rel",
107 |   Jnz: "jmp if != 0",
108 | };
109 | 
110 | const ResLogics: ResLogicsType = {
111 |   Op1: "Op1",
112 |   Add: "Add",
113 |   Mul: "Mul",
114 |   Unused: "Unused",
115 | };
116 | 
117 | const Opcodes: OpcodesType = {
118 |   NOp: "",
119 |   Call: "Call",
120 |   Ret: "Ret",
121 |   AssertEq: "AssertEq",
122 | };
123 | 
124 | const ApUpdates: ApUpdatesType = {
125 |   Constant: "AP",
126 |   AddRes: "AP + res",
127 |   Add1: "AP + 1",
128 |   Add2: "AP + 2",
129 | };
130 | 
131 | const FpUpdates: FpUpdatesType = {
132 |   Constant: "FP",
133 |   Dst: "Dst",
134 |   ApPlus2: "AP + 2",
135 | };
136 | 
137 | const FINAL_FP: string = "final_fp";
138 | const FINAL_PC: string = "final_pc";
139 | 
140 | const layouts: { [key: string]: Layout } = {
141 |   plain: {
142 |     builtins: [],
143 |   },
144 |   small: {
145 |     builtins: ["output", "pedersen", "range_check", "ecdsa"],
146 |   },
147 |   dex: {
148 |     builtins: ["output", "pedersen", "range_check", "ecdsa"],
149 |   },
150 |   recursive: {
151 |     builtins: ["output", "pedersen", "range_check", "bitwise"],
152 |   },
153 |   starknet: {
154 |     builtins: [
155 |       "output",
156 |       "pedersen",
157 |       "range_check",
158 |       "ecdsa",
159 |       "bitwise",
160 |       "ec_op",
161 |       "poseidon",
162 |     ],
163 |   },
164 |   starknet_with_keccak: {
165 |     builtins: [
166 |       "output",
167 |       "pedersen",
168 |       "range_check",
169 |       "ecdsa",
170 |       "bitwise",
171 |       "ec_op",
172 |       "keccak",
173 |       "poseidon",
174 |     ],
175 |   },
176 |   recursive_large_output: {
177 |     builtins: ["output", "pedersen", "range_check", "bitwise", "poseidon"],
178 |   },
179 |   recursive_with_poseidon: {
180 |     builtins: ["output", "pedersen", "range_check", "bitwise", "poseidon"],
181 |   },
182 |   all_cairo: {
183 |     builtins: [
184 |       "output",
185 |       "pedersen",
186 |       "range_check",
187 |       "ecdsa",
188 |       "bitwise",
189 |       "ec_op",
190 |       "keccak",
191 |       "poseidon",
192 |       "range_check96",
193 |     ],
194 |   },
195 |   all_solidity: {
196 |     builtins: [
197 |       "output",
198 |       "pedersen",
199 |       "range_check",
200 |       "ecdsa",
201 |       "bitwise",
202 |       "ec_op",
203 |     ],
204 |   },
205 |   dynamic: {
206 |     builtins: [
207 |       "output",
208 |       "pedersen",
209 |       "range_check",
210 |       "ecdsa",
211 |       "bitwise",
212 |       "ec_op",
213 |     ],
214 |   },
215 | };
216 | 


--------------------------------------------------------------------------------
/src/vm/errors.ts:
--------------------------------------------------------------------------------
 1 | class NonZeroHighBitError extends Error {}
 2 | class InvalidPcUpdateError extends Error {}
 3 | class InvalidResError extends Error {}
 4 | class InvalidOpcodeError extends Error {}
 5 | class InvalidApUpdateError extends Error {}
 6 | class InvalidOp0RegisterError extends Error {}
 7 | class InvalidOp1RegisterError extends Error {}
 8 | class InvalidDstRegisterError extends Error {}
 9 | class InvalidRangeError extends Error {}
10 | class AssertEqError extends Error {}
11 | class InvalidCellSumError extends Error {}
12 | class InvalidLoopRegisters extends Error {}
13 | 


--------------------------------------------------------------------------------
/src/vm/instructions.ts:
--------------------------------------------------------------------------------
  1 | interface decodedInstruction {
  2 |   Opcode: string;
  3 |   Op0Register: string;
  4 |   Op1Register: string;
  5 |   DstRegister: string;
  6 |   ResLogic: string;
  7 |   Op0Offset: number;
  8 |   Op1Offset: number;
  9 |   DstOffset: number;
 10 |   PcUpdate: string;
 11 |   ApUpdate: string;
 12 |   FpUpdate: string;
 13 | }
 14 | 
 15 | interface traceInfo {
 16 |   dstOffset: number;
 17 |   op0Offset: number;
 18 |   op1Offset: number;
 19 |   flags: number[];
 20 | }
 21 | 
 22 | function fromBiasedRepresentation(offset: bigint): number {
 23 |   const bias: bigint = BigInt(1) << BigInt(15);
 24 |   return Number(BigInt(Number(offset)) - bias);
 25 | }
 26 | 
 27 | function toSignedInteger(encodedInstruction): bigint {
 28 |   const number: bigint = BigInt(encodedInstruction);
 29 |   return number > BigInt(2 ** 128) ? number - PRIME : number;
 30 | }
 31 | 
 32 | function toUnsignedInteger(encodedInstruction): bigint {
 33 |   const number: bigint = BigInt(encodedInstruction);
 34 |   return number < 0 ? number + PRIME : number;
 35 | }
 36 | 
 37 | function size(instruction): number {
 38 |   return instruction.Op1Register === Registers.PC ? 2 : 1;
 39 | }
 40 | 
 41 | function decodeInstruction(encodedInstruction: bigint): decodedInstruction {
 42 |   const HighBit: bigint = BigInt(1) << BigInt(63);
 43 |   const DstRegMask: bigint = BigInt(0x0001);
 44 |   const DstRegOff: bigint = BigInt(0);
 45 |   const Op0RegMask: bigint = BigInt(0x0002);
 46 |   const Op0RegOff: bigint = BigInt(1);
 47 |   const Op1SrcMask: bigint = BigInt(0x001c);
 48 |   const Op1SrcOff: bigint = BigInt(2);
 49 |   const ResLogicMask: bigint = BigInt(0x0060);
 50 |   const ResLogicOff: bigint = BigInt(5);
 51 |   const PcUpdateMask: bigint = BigInt(0x0380);
 52 |   const PcUpdateOff: bigint = BigInt(7);
 53 |   const ApUpdateMask: bigint = BigInt(0x0c00);
 54 |   const ApUpdateOff: bigint = BigInt(10);
 55 |   const OpcodeMask: bigint = BigInt(0x7000);
 56 |   const OpcodeOff: bigint = BigInt(12);
 57 | 
 58 |   if ((encodedInstruction & HighBit) !== BigInt(0)) {
 59 |     throw new NonZeroHighBitError();
 60 |   }
 61 | 
 62 |   const dstOffset: number = this.fromBiasedRepresentation(
 63 |     encodedInstruction & BigInt(0xffff),
 64 |   );
 65 |   const op0Offset: number = this.fromBiasedRepresentation(
 66 |     (encodedInstruction >> BigInt(16)) & BigInt(0xffff),
 67 |   );
 68 |   const op1Offset: number = this.fromBiasedRepresentation(
 69 |     (encodedInstruction >> BigInt(32)) & BigInt(0xffff),
 70 |   );
 71 | 
 72 |   const flags: bigint = encodedInstruction >> BigInt(48);
 73 | 
 74 |   const dstRegNum: bigint = (flags & DstRegMask) >> DstRegOff;
 75 |   const op0RegNum: bigint = (flags & Op0RegMask) >> Op0RegOff;
 76 |   const op1SrcNum: bigint = (flags & Op1SrcMask) >> Op1SrcOff;
 77 |   const resLogicNum: bigint = (flags & ResLogicMask) >> ResLogicOff;
 78 |   const pcUpdateNum: bigint = (flags & PcUpdateMask) >> PcUpdateOff;
 79 |   const apUpdateNum: bigint = (flags & ApUpdateMask) >> ApUpdateOff;
 80 |   const opCodeNum: bigint = (flags & OpcodeMask) >> OpcodeOff;
 81 | 
 82 |   let dstRegister: string;
 83 |   let op0Register: string;
 84 |   let op1Src: string;
 85 |   let pcUpdate: string;
 86 |   let res: string;
 87 |   let opcode: string;
 88 |   let apUpdate: string;
 89 |   let fpUpdate: string;
 90 | 
 91 |   switch (dstRegNum) {
 92 |     case BigInt(0):
 93 |       dstRegister = Registers.AP;
 94 |       break;
 95 |     case BigInt(1):
 96 |       dstRegister = Registers.FP;
 97 |       break;
 98 |     default:
 99 |       throw new InvalidDstRegisterError();
100 |   }
101 | 
102 |   switch (op0RegNum) {
103 |     case BigInt(0):
104 |       op0Register = Registers.AP;
105 |       break;
106 |     case BigInt(1):
107 |       op0Register = Registers.FP;
108 |       break;
109 |     default:
110 |       throw new InvalidOp0RegisterError();
111 |   }
112 | 
113 |   switch (op1SrcNum) {
114 |     case BigInt(0):
115 |       op1Src = Op1Src.Op0;
116 |       break;
117 |     case BigInt(1):
118 |       op1Src = Op1Src.PC;
119 |       break;
120 |     case BigInt(2):
121 |       op1Src = Op1Src.FP;
122 |       break;
123 |     case BigInt(4):
124 |       op1Src = Op1Src.AP;
125 |       break;
126 |     default:
127 |       throw new InvalidOp1RegisterError();
128 |   }
129 | 
130 |   switch (opCodeNum) {
131 |     case BigInt(0):
132 |       opcode = Opcodes.NOp;
133 |       break;
134 |     case BigInt(1):
135 |       opcode = Opcodes.Call;
136 |       break;
137 |     case BigInt(2):
138 |       opcode = Opcodes.Ret;
139 |       break;
140 |     case BigInt(4):
141 |       opcode = Opcodes.AssertEq;
142 |       break;
143 |     default:
144 |       throw new InvalidOpcodeError();
145 |   }
146 | 
147 |   switch (apUpdateNum) {
148 |     case BigInt(0):
149 |       if (opcode === Opcodes.Call) {
150 |         apUpdate = ApUpdates.Add2;
151 |       } else {
152 |         apUpdate = ApUpdates.Constant;
153 |       }
154 |       break;
155 |     case BigInt(1):
156 |       apUpdate = ApUpdates.AddRes;
157 |       break;
158 |     case BigInt(2):
159 |       apUpdate = ApUpdates.Add1;
160 |       break;
161 |     default:
162 |       throw new InvalidApUpdateError();
163 |   }
164 | 
165 |   switch (opcode) {
166 |     case Opcodes.NOp:
167 |       fpUpdate = FpUpdates.Constant;
168 |       break;
169 |     case Opcodes.Call:
170 |       fpUpdate = FpUpdates.ApPlus2;
171 |       break;
172 |     case Opcodes.Ret:
173 |       fpUpdate = FpUpdates.Dst;
174 |       break;
175 |     case Opcodes.AssertEq:
176 |       fpUpdate = FpUpdates.Constant;
177 |       break;
178 |     default:
179 |       throw new InvalidOpcodeError();
180 |   }
181 | 
182 |   switch (pcUpdateNum) {
183 |     case BigInt(0):
184 |       pcUpdate = PcUpdates.Regular;
185 |       break;
186 |     case BigInt(1):
187 |       pcUpdate = PcUpdates.Jump;
188 |       break;
189 |     case BigInt(2):
190 |       pcUpdate = PcUpdates.JumpRel;
191 |       break;
192 |     case BigInt(4):
193 |       pcUpdate = PcUpdates.Jnz;
194 |       break;
195 |     default:
196 |       throw new InvalidPcUpdateError();
197 |   }
198 | 
199 |   switch (resLogicNum) {
200 |     case BigInt(0):
201 |       res = ResLogics.Op1;
202 |       break;
203 |     case BigInt(1):
204 |       res = ResLogics.Add;
205 |       break;
206 |     case BigInt(2):
207 |       res = ResLogics.Mul;
208 |       break;
209 |     default:
210 |       throw new InvalidResError();
211 |   }
212 | 
213 |   return {
214 |     Opcode: opcode,
215 |     Op0Register: op0Register,
216 |     Op1Register: op1Src,
217 |     DstRegister: dstRegister,
218 |     ResLogic: res,
219 |     Op0Offset: op0Offset,
220 |     Op1Offset: op1Offset,
221 |     DstOffset: dstOffset,
222 |     PcUpdate: pcUpdate,
223 |     ApUpdate: apUpdate,
224 |     FpUpdate: fpUpdate,
225 |   };
226 | }
227 | 
228 | function getTraceInfo(encodedInstruction: bigint): traceInfo {
229 |   const dstOffset: number = Number(encodedInstruction & BigInt(0xffff));
230 |   const op0Offset: number = Number(
231 |     (encodedInstruction >> BigInt(16)) & BigInt(0xffff),
232 |   );
233 |   const op1Offset: number = Number(
234 |     (encodedInstruction >> BigInt(32)) & BigInt(0xffff),
235 |   );
236 | 
237 |   let flagsBigint: bigint = encodedInstruction >> BigInt(48);
238 |   let flags: number[] = bigintTo15BitString(flagsBigint)
239 |     .split("")
240 |     .map((flag) => Number(flag))
241 |     .reverse();
242 | 
243 |   return { dstOffset, op0Offset, op1Offset, flags };
244 | }
245 | 


--------------------------------------------------------------------------------
/src/vm/vm.ts:
--------------------------------------------------------------------------------
  1 | const runSheet: GoogleAppsScript.Spreadsheet.Sheet =
  2 |   SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Run");
  3 | const proverSheet: GoogleAppsScript.Spreadsheet.Sheet =
  4 |   SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Prover");
  5 | const programSheet: GoogleAppsScript.Spreadsheet.Sheet =
  6 |   SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Program");
  7 | 
  8 | const columns: String[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
  9 | 
 10 | let i = 0;
 11 | const pcColumn: string = indexToColumn(i);
 12 | i++;
 13 | const fpColumn: string = indexToColumn(i);
 14 | i++;
 15 | const apColumn: string = indexToColumn(i);
 16 | i++;
 17 | const opcodeColumn: string = indexToColumn(i);
 18 | i++;
 19 | const dstColumn: string = indexToColumn(i);
 20 | i++;
 21 | const resColumn: string = indexToColumn(i);
 22 | i++;
 23 | const op0Column: string = indexToColumn(i);
 24 | i++;
 25 | const runOp1Column: string = indexToColumn(i);
 26 | i++;
 27 | const executionColumn: string = indexToColumn(i);
 28 | i++;
 29 | const firstBuiltinColumn: string = indexToColumn(i);
 30 | i++;
 31 | 
 32 | let j = 0;
 33 | const progBytecodeColumn: string = indexToColumn(j);
 34 | j++;
 35 | const progOpcodeColumn: string = indexToColumn(j);
 36 | j++;
 37 | const progDstColumn: string = indexToColumn(j);
 38 | j++;
 39 | const progOpColumn: string = indexToColumn(j);
 40 | j++;
 41 | const progPcupdateColumn: string = indexToColumn(j);
 42 | j++;
 43 | const progApupdateColumn: string = indexToColumn(j);
 44 | j++;
 45 | const progFpupdateColumn: string = indexToColumn(j);
 46 | j++;
 47 | const progDecInstructionColumn: string = indexToColumn(j);
 48 | j++;
 49 | const progDstOffsetColumn: string = indexToColumn(j);
 50 | j++;
 51 | const progOp0OffsetColumn: string = indexToColumn(j);
 52 | j++;
 53 | const progOp1OffsetColumn: string = indexToColumn(j);
 54 | j++;
 55 | const progFlag0Column: string = indexToColumn(j);
 56 | j += 15;
 57 | const progFlag15Column: string = indexToColumn(j);
 58 | j++;
 59 | 
 60 | let k = 0;
 61 | const provSegmentsColumn: string = indexToColumn(k);
 62 | k++;
 63 | const provAddressColumn: string = indexToColumn(k);
 64 | k++;
 65 | const provValuesColumn: string = indexToColumn(k);
 66 | k++;
 67 | const provMemoryRelocatedColumn: string = indexToColumn(k);
 68 | k++;
 69 | const provRelocatedPcColumn: string = indexToColumn(k);
 70 | k++;
 71 | const provRelocatedFpColumn: string = indexToColumn(k);
 72 | k++;
 73 | const provRelocatedApColumn: string = indexToColumn(k);
 74 | k++;
 75 | 
 76 | type Builtins = {
 77 |   output: BuitlinType;
 78 |   pedersen: BuitlinType;
 79 |   range_check: BuitlinType;
 80 |   range_check96: BuitlinType;
 81 |   ecdsa: BuitlinType;
 82 |   bitwise: BuitlinType;
 83 |   ec_op: BuitlinType;
 84 |   keccak: BuitlinType;
 85 |   poseidon: BuitlinType;
 86 | };
 87 | 
 88 | let builtins: Builtins = {
 89 |   output: {
 90 |     freeCellsPerBuiltin: 0,
 91 |     numOutputCells: 0,
 92 |     column: "",
 93 |     functionName: "OUTPUT",
 94 |   },
 95 |   pedersen: {
 96 |     freeCellsPerBuiltin: 2,
 97 |     numOutputCells: 1,
 98 |     column: "",
 99 |     functionName: "PEDERSEN",
100 |   },
101 |   range_check: {
102 |     freeCellsPerBuiltin: 0,
103 |     numOutputCells: 1,
104 |     column: "",
105 |     functionName: "RANGE_CHECK",
106 |   },
107 |   range_check96: {
108 |     freeCellsPerBuiltin: 0,
109 |     numOutputCells: 1,
110 |     column: "",
111 |     functionName: "RANGE_CHECK96",
112 |   },
113 |   ecdsa: {
114 |     freeCellsPerBuiltin: 3,
115 |     numOutputCells: 1,
116 |     column: "",
117 |     functionName: "CHECK_ECDSA_SIGNATURE",
118 |   },
119 |   bitwise: {
120 |     freeCellsPerBuiltin: 2,
121 |     numOutputCells: 3,
122 |     column: "",
123 |     functionName: "BITWISE",
124 |   },
125 |   ec_op: {
126 |     freeCellsPerBuiltin: 5,
127 |     numOutputCells: 2,
128 |     column: "",
129 |     functionName: "EC_OP",
130 |   },
131 |   keccak: {
132 |     freeCellsPerBuiltin: 8,
133 |     numOutputCells: 8,
134 |     column: "",
135 |     functionName: "KECCAK",
136 |   },
137 |   poseidon: {
138 |     freeCellsPerBuiltin: 3,
139 |     numOutputCells: 3,
140 |     column: "",
141 |     functionName: "POSEIDON",
142 |   },
143 | };
144 | 
145 | function reorderBuiltins(builtinsList: string[], layout: Layout): string[] {
146 |   const layoutBuiltins = layout.builtins;
147 | 
148 |   const orderedBuiltins = builtinsList.filter((builtin) =>
149 |     layoutBuiltins.includes(builtin),
150 |   );
151 |   const unorderedBuiltins = builtinsList.filter(
152 |     (builtin) => !layoutBuiltins.includes(builtin),
153 |   );
154 | 
155 |   const result = layoutBuiltins.filter((builtin) =>
156 |     orderedBuiltins.includes(builtin),
157 |   );
158 | 
159 |   return [...result, ...unorderedBuiltins];
160 | }
161 | 
162 | let builtinsColumns: {};
163 | function initializeProgram(program: any, isProofMode: boolean, layout: Layout) {
164 |   const usedBuiltins: string[] = program.builtins;
165 |   let builtinsList: string[] = isProofMode
166 |     ? [...new Set(usedBuiltins.concat(layout.builtins))]
167 |     : usedBuiltins;
168 | 
169 |   let counter: number = 0;
170 |   const executionColumnOffset: number = columnToIndex(executionColumn) + 1;
171 | 
172 |   let builtinsListOrdered: string[] = reorderBuiltins(builtinsList, layout);
173 | 
174 |   for (var key of builtinsListOrdered) {
175 |     builtins[key].column = indexToColumn(counter + executionColumnOffset);
176 |     counter++;
177 |   }
178 | 
179 |   const builtinStack = builtinsListOrdered
180 |     .map((builtin) => {
181 |       let base: string = `${builtins[builtin].column}2`;
182 |       if (isProofMode) {
183 |         return usedBuiltins.includes(builtin) ? base : 0;
184 |       }
185 |       return base;
186 |     })
187 |     .filter((value) => !(value === 0));
188 | 
189 |   let stack: string[] = [];
190 |   if (!isProofMode) {
191 |     let fpColumn: string =
192 |       program.builtins.length != 0
193 |         ? indexToColumn(
194 |             columnToIndex(
195 |               builtins[builtinsListOrdered[builtinsListOrdered.length - 1]]
196 |                 .column,
197 |             ) + 1,
198 |           )
199 |         : indexToColumn(columnToIndex(executionColumn) + 1);
200 |     let pcColumn: string =
201 |       program.builtins.length != 0
202 |         ? indexToColumn(
203 |             columnToIndex(
204 |               builtins[builtinsListOrdered[builtinsListOrdered.length - 1]]
205 |                 .column,
206 |             ) + 2,
207 |           )
208 |         : indexToColumn(columnToIndex(executionColumn) + 2);
209 |     stack = [...builtinStack, `${fpColumn}2`, `${pcColumn}2`];
210 |     runSheet
211 |       .getRange(
212 |         `${indexToColumn(columnToIndex(executionColumn) + 1)}1:${pcColumn}1`,
213 |       )
214 |       .setValues([[...builtinsListOrdered, FINAL_FP, FINAL_PC]]);
215 |     programSheet
216 |       .getRange(`B${Number(getFinalPcCell().substring(1)) + 1}`)
217 |       .setValue(`${executionColumn}${stack.length + 2}`);
218 |     programSheet.getRange(getFinalPcCell()).setValue(`${pcColumn}2`);
219 |   } else {
220 |     stack = [`${executionColumn}2`, "0", ...builtinStack];
221 |     programSheet
222 |       .getRange(`B${Number(getFinalPcCell().substring(1)) + 1}`)
223 |       .setValue(`${executionColumn}${2}`);
224 |     programSheet
225 |       .getRange(getFinalPcCell())
226 |       .setValue(program["identifiers"]["__main__.__end__"]["pc"]);
227 | 
228 |     if (builtinsListOrdered.length > 0) {
229 |       runSheet
230 |         .getRange(
231 |           `${builtins[builtinsListOrdered[0]].column}1:${builtins[builtinsListOrdered[builtinsListOrdered.length - 1]].column}1`,
232 |         )
233 |         .setValues([builtinsListOrdered]);
234 |     }
235 |   }
236 |   runSheet
237 |     .getRange(`${executionColumn}2:${executionColumn}${stack.length + 1}`)
238 |     .setValues(stack.map((address) => [address]));
239 | 
240 |   runSheet
241 |     .getRange(`${pcColumn}2`)
242 |     .setFormula(`=Program!B${Number(getFinalPcCell().substring(1)) - 1}`);
243 |   runSheet
244 |     .getRange(`${apColumn}2`)
245 |     .setFormula(`=Program!B${Number(getFinalPcCell().substring(1)) + 1}`);
246 |   runSheet.getRange(`${fpColumn}2`).setFormula(`=${apColumn}2`);
247 | }
248 | 
249 | function step(n: number = 0): void {
250 |   const program: any[][] = programSheet.getRange("A2:A").getValues();
251 |   updateBuiltins();
252 | 
253 |   const registersAddress: RegistersType = {
254 |     PC: `${pcColumn}${n + 2}`,
255 |     FP: `${fpColumn}${n + 2}`,
256 |     AP: `${apColumn}${n + 2}`,
257 |   };
258 |   const pc: string = runSheet.getRange(registersAddress["PC"]).getValue();
259 |   const fp: string = runSheet.getRange(registersAddress["FP"]).getValue();
260 |   const ap: string = runSheet.getRange(registersAddress["AP"]).getValue();
261 |   const registers: RegistersType = {
262 |     PC: pc,
263 |     FP: fp,
264 |     AP: ap,
265 |   };
266 | 
267 |   const encodedInstruction: any =
268 |     program[runSheet.getRange(pc).getRow() - 2][0];
269 |   const instruction: decodedInstruction = decodeInstruction(
270 |     BigInt(encodedInstruction),
271 |   );
272 |   runSheet.getRange(`${opcodeColumn}${n + 2}`).setValue(instruction.Opcode);
273 | 
274 |   const op0Index: number =
275 |     runSheet.getRange(registers[instruction.Op0Register]).getRow() -
276 |     2 +
277 |     instruction.Op0Offset;
278 |   const dstIndex: number =
279 |     runSheet.getRange(registers[instruction.DstRegister]).getRow() -
280 |     2 +
281 |     instruction.DstOffset;
282 |   let op1Index: number;
283 | 
284 |   // Addresses are sheet address (e.g. H4) or constants
285 |   // Constants come from the Program, ie when register is PC
286 |   // Indexes are +2 since the CairoVM is 0 based, while the Sheet is 1 base
287 |   // and the first row is a header
288 |   let op0Addr: string =
289 |     instruction.Op0Register === Registers.PC
290 |       ? `Program!${progOpColumn}${op0Index + 2}`
291 |       : `${executionColumn}${op0Index + 2}`;
292 |   let op1Addr: string;
293 |   let dstAddr: string =
294 |     instruction.DstRegister === Registers.PC
295 |       ? `Program!${progOpColumn}${dstIndex + 2}`
296 |       : `${executionColumn}${dstIndex + 2}`;
297 |   let op0Value: string = runSheet.getRange(op0Addr).getValue();
298 |   let dstValue: string = runSheet.getRange(dstAddr).getValue();
299 | 
300 |   switch (instruction.Op1Register) {
301 |     case Op1Src.Op0:
302 |       //instruction.Op0Register can't be Registers.PC because we expect op0Value to be an pointer to a segment emplacement and not a felt
303 |       //So there is no need to deal with this case.
304 |       let op0ValueColumn: string = indexToColumn(
305 |         runSheet.getRange(op0Value).getColumn() - 1,
306 |       );
307 |       let op0ValueRow: number = runSheet.getRange(op0Value).getRow();
308 |       op1Addr = `${op0ValueColumn}${op0ValueRow + instruction.Op1Offset}`;
309 |       break;
310 |     case Op1Src.PC:
311 |       op1Index =
312 |         runSheet.getRange(registers[instruction.Op1Register]).getRow() -
313 |         2 +
314 |         instruction.Op1Offset;
315 |       op1Addr = `Program!${progOpColumn}${op1Index + 2}`;
316 |       break;
317 |     default:
318 |       op1Index =
319 |         runSheet.getRange(registers[instruction.Op1Register]).getRow() -
320 |         2 +
321 |         instruction.Op1Offset;
322 |       op1Addr = `${executionColumn}${op1Index + 2}`;
323 |       break;
324 |   }
325 | 
326 |   builtinsColumns = Object.fromEntries(
327 |     Object.keys(builtins)
328 |       .filter((builtin) => !!builtins[builtin] && builtins[builtin].column)
329 |       .map((builtin) => [builtins[builtin].column, builtins[builtin]]),
330 |   );
331 |   let addr = op1Addr.split("!").pop();
332 |   let op1Column = addr[0];
333 |   let op1Offset = Number(addr.slice(1)) - 2;
334 |   if (Object.keys(builtinsColumns).includes(op1Column)) {
335 |     const builtin = builtinsColumns[op1Column];
336 |     if (builtin.freeCellsPerBuiltin > 0) {
337 |       const builtinSize = builtin.freeCellsPerBuiltin + builtin.numOutputCells;
338 | 
339 |       const requiredInstances =
340 |         op1Offset > 0 ? Math.ceil(op1Offset / builtinSize) : 1;
341 |       const lastInstance = (requiredInstances - 1) * builtinSize;
342 |       const lastBuiltinCell = requiredInstances * builtinSize;
343 |       if (
344 |         runSheet.getRange(`${op1Column}${lastBuiltinCell + 1}`).getFormula() ==
345 |         ""
346 |       ) {
347 |         var inputCells: string[] = [];
348 |         for (let j = 1; j <= builtin.freeCellsPerBuiltin; j++) {
349 |           inputCells.push(`${op1Column}${lastInstance + j + 1}`);
350 |         }
351 |         runSheet
352 |           .getRange(
353 |             `${builtin.column}${lastInstance + 1 + builtin.freeCellsPerBuiltin + 1}`,
354 |           )
355 |           .setFormula(
356 |             `=${builtin.functionName}(${inputCells[0]}:${inputCells[inputCells.length - 1]})`,
357 |           );
358 |       }
359 |     }
360 |   }
361 | 
362 |   if (builtins["range_check"].column != "") {
363 |     for (
364 |       let j = 2;
365 |       j <=
366 |       getLastActiveFormulaRowNumber(builtins["range_check"].column, runSheet);
367 |       j++
368 |     ) {
369 |       let currentCell: string = `${builtins["range_check"].column}${j}`;
370 |       let currentCellFormula: string = runSheet
371 |         .getRange(currentCell)
372 |         .getFormula();
373 |       if (currentCellFormula[1] != "R") {
374 |         runSheet
375 |           .getRange(currentCell)
376 |           .setFormula(`=RANGE_CHECK(${currentCellFormula.substring(1)})`);
377 |       }
378 |     }
379 |   }
380 | 
381 |   if (builtins["range_check96"].column != "") {
382 |     for (
383 |       let j = 2;
384 |       j <=
385 |       getLastActiveFormulaRowNumber(builtins["range_check96"].column, runSheet);
386 |       j++
387 |     ) {
388 |       let currentCell: string = `${builtins["range_check96"].column}${j}`;
389 |       let currentCellFormula: string = runSheet
390 |         .getRange(currentCell)
391 |         .getFormula();
392 |       if (currentCellFormula[1] != "R") {
393 |         runSheet
394 |           .getRange(currentCell)
395 |           .setFormula(`=RANGE_CHECK96(${currentCellFormula.substring(1)})`);
396 |       }
397 |     }
398 |   }
399 | 
400 |   let op1Value: string = runSheet.getRange(op1Addr).getValue();
401 | 
402 |   // Set formula for current opcode: dst and res
403 |   runSheet.getRange(`${dstColumn}${n + 2}`).setFormula(`=${dstAddr}`);
404 |   switch (instruction.ResLogic) {
405 |     case ResLogics.Add:
406 |       var resFormula: string = getFormulaOfAddition(
407 |         op0Value,
408 |         op1Value,
409 |         op0Addr,
410 |         op1Addr,
411 |       );
412 |       runSheet.getRange(`${resColumn}${n + 2}`).setFormula(resFormula);
413 |       break;
414 |     case ResLogics.Mul:
415 |       runSheet
416 |         .getRange(`${resColumn}${n + 2}`)
417 |         .setFormula(`=${op0Addr} * ${op1Addr}`);
418 |       break;
419 |     case ResLogics.Op1:
420 |       runSheet.getRange(`${resColumn}${n + 2}`).setFormula(`=${op1Addr}`);
421 |       break;
422 |   }
423 |   // Cairo instructions are like
424 |   // res = res_logic(op0, op1)
425 |   // opcode(dst, res)
426 |   switch (instruction.Opcode) {
427 |     case Opcodes.Call:
428 |       let validCallOp0Value: string = addSegmentValues(
429 |         registers[Registers.PC],
430 |         size(instruction).toString(10),
431 |       );
432 |       let validCallDstValue: string = registers[Registers.FP];
433 |       if (op0Value == "") {
434 |         runSheet.getRange(op0Addr).setFormula(`="${validCallOp0Value}"`);
435 |         op0Value = runSheet.getRange(op0Addr).getValue();
436 |       }
437 |       if (dstValue == "") {
438 |         runSheet.getRange(dstAddr).setFormula(`="${validCallDstValue}"`);
439 |         dstValue = runSheet.getRange(dstAddr).getValue();
440 |       }
441 | 
442 |       if (dstValue != validCallDstValue || op0Value != validCallOp0Value) {
443 |         throw new AssertEqError();
444 |       }
445 |       break;
446 |     case Opcodes.AssertEq:
447 |       let validAssertEqDstValue: string;
448 |       switch (instruction.ResLogic) {
449 |         case ResLogics.Add:
450 |           if (op0Value === "") {
451 |             runSheet
452 |               .getRange(op0Addr)
453 |               .setFormula(`="${addSegmentValues(dstValue, `-${op1Value}"`)}`);
454 |             op0Value = runSheet.getRange(op0Addr).getValue();
455 |           }
456 |           if (op1Value === "") {
457 |             runSheet
458 |               .getRange(op1Addr)
459 |               .setFormula(`="${addSegmentValues(dstValue, `-${op0Value}"`)}`);
460 |             op1Value = runSheet.getRange(op1Addr).getValue();
461 |           }
462 |           if (dstValue === "") {
463 |             runSheet
464 |               .getRange(dstAddr)
465 |               .setFormula(
466 |                 `="${addSegmentValues(`${op0Value}`, `${op1Value}`)}"`,
467 |               );
468 |           }
469 |           validAssertEqDstValue = addSegmentValues(op0Value, op1Value);
470 |           break;
471 |         case ResLogics.Mul:
472 |           if (op0Value === "") {
473 |             runSheet
474 |               .getRange(op0Addr)
475 |               .setFormula(`="${BigInt(dstValue) / BigInt(op1Value)}"`);
476 |             op0Value = runSheet.getRange(op0Addr).getValue();
477 |           }
478 |           if (op1Value === "") {
479 |             runSheet
480 |               .getRange(op1Addr)
481 |               .setFormula(`="${BigInt(dstValue) / BigInt(op0Value)}"`);
482 |             op1Value = runSheet.getRange(op1Addr).getValue();
483 |           }
484 |           if (dstValue === "") {
485 |             runSheet
486 |               .getRange(dstAddr)
487 |               .setFormula(`="${BigInt(op0Value) * BigInt(op1Value)}"`);
488 |           }
489 |           validAssertEqDstValue = Number(
490 |             BigInt(op0Value) * BigInt(op1Value),
491 |           ).toString(10);
492 |           break;
493 |         case ResLogics.Op1:
494 |           if (op1Value === "") {
495 |             runSheet.getRange(op1Addr).setFormula(`="${dstValue}"`);
496 |             op1Value = runSheet.getRange(op1Addr).getValue();
497 |           }
498 |           if (dstValue === "") {
499 |             runSheet.getRange(dstAddr).setFormula(`="${op1Value}"`);
500 |           }
501 |           validAssertEqDstValue = op1Value;
502 |           break;
503 |       }
504 |       dstValue = runSheet.getRange(dstAddr).getValue();
505 |       if (dstValue != validAssertEqDstValue) {
506 |         throw new AssertEqError();
507 |       }
508 |       break;
509 |   }
510 | 
511 |   runSheet.getRange(`${op0Column}${n + 2}`).setFormula(`=${op0Addr}`);
512 |   runSheet.getRange(`${runOp1Column}${n + 2}`).setFormula(`=${op1Addr}`);
513 | 
514 |   const resValue: string = runSheet.getRange(`${resColumn}${n + 2}`).getValue();
515 | 
516 |   switch (instruction.PcUpdate) {
517 |     case PcUpdates.Jump:
518 |       runSheet
519 |         .getRange(`${pcColumn}${n + 2 + 1}`)
520 |         .setFormula(`=${resColumn}${n + 2}`);
521 |       break;
522 |     case PcUpdates.JumpRel:
523 |       runSheet
524 |         .getRange(`${pcColumn}${n + 2 + 1}`)
525 |         .setFormula(
526 |           getFormulaOfAddition(
527 |             pc,
528 |             resValue,
529 |             `${pcColumn}${n + 2}`,
530 |             `${resColumn}${n + 2}`,
531 |           ),
532 |         );
533 |       break;
534 |     case PcUpdates.Jnz:
535 |       runSheet
536 |         .getRange(`${pcColumn}${n + 2 + 1}`)
537 |         .setFormula(
538 |           getFormulaOfAddition(
539 |             pc,
540 |             dstValue == "0" ? size(instruction).toString(10) : resValue,
541 |             `${pcColumn}${n + 2}`,
542 |             dstValue == "0"
543 |               ? size(instruction).toString(10)
544 |               : `${resColumn}${n + 2}`,
545 |           ),
546 |         );
547 |       break;
548 |     case PcUpdates.Regular:
549 |       runSheet
550 |         .getRange(`${pcColumn}${n + 2 + 1}`)
551 |         .setFormula(
552 |           getFormulaOfAddition(
553 |             pc,
554 |             `${size(instruction)}`,
555 |             `${pcColumn}${n + 2}`,
556 |             `${size(instruction)}`,
557 |           ),
558 |         );
559 |       break;
560 |   }
561 | 
562 |   switch (instruction.FpUpdate) {
563 |     case FpUpdates.Constant:
564 |       runSheet
565 |         .getRange(`${fpColumn}${n + 2 + 1}`)
566 |         .setFormula(`=${fpColumn}${n + 2}`);
567 |       break;
568 |     case FpUpdates.ApPlus2:
569 |       runSheet
570 |         .getRange(`${fpColumn}${n + 2 + 1}`)
571 |         .setFormula(getFormulaOfAddition(ap, "2", `${apColumn}${n + 2}`, "2"));
572 |       break;
573 |     case FpUpdates.Dst:
574 |       runSheet
575 |         .getRange(`${fpColumn}${n + 2 + 1}`)
576 |         .setFormula(`=${dstColumn}${n + 2}`);
577 |       break;
578 |   }
579 | 
580 |   switch (instruction.ApUpdate) {
581 |     case ApUpdates.Add1:
582 |       runSheet
583 |         .getRange(`${apColumn}${n + 2 + 1}`)
584 |         .setFormula(getFormulaOfAddition(ap, `1`, `${apColumn}${n + 2}`, "1"));
585 |       break;
586 |     case ApUpdates.Add2:
587 |       runSheet
588 |         .getRange(`${apColumn}${n + 2 + 1}`)
589 |         .setFormula(getFormulaOfAddition(ap, `2`, `${apColumn}${n + 2}`, "2"));
590 |       break;
591 |     case ApUpdates.AddRes:
592 |       runSheet
593 |         .getRange(`${apColumn}${n + 2 + 1}`)
594 |         .setFormula(
595 |           getFormulaOfAddition(
596 |             ap,
597 |             resValue,
598 |             `${apColumn}${n + 2}`,
599 |             `${resColumn}${n + 2}`,
600 |           ),
601 |         );
602 |       break;
603 |     case ApUpdates.Constant:
604 |       runSheet
605 |         .getRange(`${apColumn}${n + 2 + 1}`)
606 |         .setFormula(`=${apColumn}${n + 2}`);
607 |       break;
608 |   }
609 | }
610 | 
611 | function runUntilPc(): number {
612 |   let i: number = getLastActiveRowNumber(`${pcColumn}`, runSheet) - 2;
613 |   let pc: string = runSheet.getRange(`${pcColumn}${i + 1 + 1}`).getValue();
614 |   while (!isFinalPc(pc)) {
615 |     step(i);
616 |     i++;
617 |     pc = runSheet.getRange(`${pcColumn}${i + 1 + 1}`).getValue();
618 |   }
619 |   return i + 1; //number of steps exectued (i+2 is the row of the new registers)
620 | }
621 | 
622 | function relocateMemory() {
623 |   let formulas: string[] = [];
624 |   let columnIndex: number = columnToIndex(executionColumn);
625 |   let maxProgramRow: number = getLastActiveRowNumber(
626 |     progDecInstructionColumn,
627 |     programSheet,
628 |   );
629 |   for (let row = 2; row <= maxProgramRow; row++) {
630 |     formulas.push(`=Program!${progBytecodeColumn}${row}`);
631 |   }
632 |   while (runSheet.getRange(1, columnIndex + 1).getValue() != "") {
633 |     let currentColumn: string = indexToColumn(columnIndex);
634 |     let maxRowNumber: number = getLastActiveRowNumber(currentColumn, runSheet);
635 |     if (maxRowNumber == 1) {
636 |       columnIndex++;
637 |       continue;
638 |     }
639 |     for (let row = 2; row <= maxRowNumber; row++) {
640 |       formulas.push(`=Run!${currentColumn}${row}`);
641 |     }
642 |     columnIndex++;
643 |   }
644 |   proverSheet
645 |     .getRange(3, columnToIndex(provValuesColumn) + 1, formulas.length)
646 |     .setFormulas(formulas.map((formula) => [formula]));
647 | 
648 |   proverSheet
649 |     .getRange(3, columnToIndex(provSegmentsColumn) + 1, formulas.length)
650 |     .setFormulas(
651 |       formulas.map((_, index) => [
652 |         `=FORMULATEXT(${provValuesColumn}${index + 3})`,
653 |       ]),
654 |     );
655 | 
656 |   proverSheet
657 |     .getRange(3, columnToIndex(provAddressColumn) + 1, formulas.length)
658 |     .setFormulas(
659 |       formulas.map((_, index) => {
660 |         if (index <= maxProgramRow - 2) {
661 |           return [`=REGEXEXTRACT(${provSegmentsColumn}${index + 3}; "=(.*)")`];
662 |         } else {
663 |           return [
664 |             `=REGEXEXTRACT(${provSegmentsColumn}${index + 3}; "([A-Z]+[0-9]+)$")`,
665 |           ];
666 |         }
667 |       }),
668 |     );
669 | 
670 |   let finalRegisters: number =
671 |     getLastActiveRowNumber(provAddressColumn, proverSheet) - 1;
672 |   proverSheet
673 |     .getRange(3, columnToIndex(provMemoryRelocatedColumn) + 1, formulas.length)
674 |     .setFormulas(
675 |       formulas.map((_, index) => {
676 |         let currentCell: string = `${provValuesColumn}${index + 3}`;
677 |         let searchingRange: string = `${provAddressColumn}3:${provAddressColumn}`;
678 |         Logger.log(finalRegisters);
679 |         return [
680 |           `=IFERROR(MATCH(${currentCell};${searchingRange};0); IFERROR(MATCH(LEFT(${currentCell}) & RIGHT(${currentCell}; LEN(${currentCell})-1)-1; ${searchingRange}; 0)+1; IF(IS_CELL(${currentCell});${finalRegisters};${currentCell})))`,
681 |         ];
682 |       }),
683 |     );
684 | }
685 | 
686 | function relocateTrace() {
687 |   let relocatedPCFormulas: string[] = [];
688 |   let relocatedFPFormulas: string[] = [];
689 |   let relocatedAPFormulas: string[] = [];
690 | 
691 |   let registersValue: string[][] = runSheet
692 |     .getRange(`${pcColumn}2:${apColumn}`)
693 |     .getValues();
694 |   registersValue.forEach(([pc, fp, ap], index) => {
695 |     if (Boolean(pc) && Boolean(fp) && Boolean(ap)) {
696 |       let searchingRange: string = `${provAddressColumn}3:${provAddressColumn}`;
697 |       let currentPcCell: string = `Run!${pcColumn}${index + 2}`;
698 |       let currentFpCell: string = `Run!${fpColumn}${index + 2}`;
699 |       let currentApCell: string = `Run!${apColumn}${index + 2}`;
700 |       relocatedPCFormulas.push(
701 |         `=IFERROR(MATCH(${currentPcCell};${searchingRange};0); IFERROR(MATCH(LEFT(${currentPcCell}) & RIGHT(${currentPcCell}; LEN(${currentPcCell})-1)-1; ${searchingRange}; 0)+1; ${currentPcCell}))`,
702 |       );
703 |       relocatedFPFormulas.push(
704 |         `=IFERROR(MATCH(${currentFpCell};${searchingRange};0); IFERROR(MATCH(LEFT(${currentFpCell}) & RIGHT(${currentFpCell}; LEN(${currentFpCell})-1)-1; ${searchingRange}; 0)+1; ${currentFpCell}))`,
705 |       );
706 |       relocatedAPFormulas.push(
707 |         `=IFERROR(MATCH(${currentApCell};${searchingRange};0); IFERROR(MATCH(LEFT(${currentApCell}) & RIGHT(${currentApCell}; LEN(${currentApCell})-1)-1; ${searchingRange}; 0)+1; ${currentApCell}))`,
708 |       );
709 |     }
710 |   });
711 | 
712 |   relocatedPCFormulas.pop();
713 |   relocatedFPFormulas.pop();
714 |   relocatedAPFormulas.pop();
715 | 
716 |   proverSheet
717 |     .getRange(3, 5, relocatedPCFormulas.length)
718 |     .setFormulas(relocatedPCFormulas.map((pc) => [pc]));
719 |   proverSheet
720 |     .getRange(3, 6, relocatedFPFormulas.length)
721 |     .setFormulas(relocatedFPFormulas.map((fp) => [fp]));
722 |   proverSheet
723 |     .getRange(3, 7, relocatedAPFormulas.length)
724 |     .setFormulas(relocatedAPFormulas.map((ap) => [ap]));
725 | }
726 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "compilerOptions": {
3 |     "target": "ES2019",
4 |     "lib": ["ESNext"],
5 |     "experimentalDecorators": true
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------