create-leo-app 0.7.2 → 0.8.2

package/template-node-ts/_gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

package/template-node-ts/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "node-ts-starter",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "build": "rimraf dist/js && rollup --config",
+    "dev": "npm run build && node dist/index.js"
+  },
+  "dependencies": {
+    "@provablehq/sdk": "^0.8.0"
+  },
+  "devDependencies": {
+    "rimraf": "^6.0.1",
+    "rollup": "^4.32.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "typescript": "^5.7.3"
+  }
+}

package/template-node-ts/rollup.config.js

@@ -0,0 +1,19 @@
+import typescript from "rollup-plugin-typescript2";
+
+export default {
+    input: {
+        index: "./src/index.ts",
+    },
+    output: {
+        dir: `dist`,
+        format: "es",
+        sourcemap: true,
+    },
+    external: ['@provablehq/sdk'],
+    plugins: [
+        typescript({
+            tsconfig: "tsconfig.json",
+            clean: true,
+        }),
+    ],
+};

package/template-node-ts/src/index.ts

@@ -0,0 +1,65 @@
+import {Account, initThreadPool, ProgramManager, AleoKeyProvider, AleoKeyProviderParams} from "@provablehq/sdk";
+
+await initThreadPool();
+
+const programName = "hello_hello.aleo"
+
+const hello_hello_program =`
+program ${programName};
+
+function hello:
+    input r0 as u32.public;
+    input r1 as u32.private;
+    add r0 r1 into r2;
+    output r2 as u32.private;`
+
+async function localProgramExecution(program, programName, aleoFunction, inputs) {
+    const programManager = new ProgramManager();
+
+    // Create a temporary account for the execution of the program
+    const account = new Account();
+    programManager.setAccount(account);
+
+    // Create a key provider in order to re-use the same key for each execution
+    const keyProvider = new AleoKeyProvider();
+    keyProvider.useCache(true);
+    programManager.setKeyProvider(keyProvider);
+
+    // Pre-synthesize the program keys and then cache them in memory using key provider
+    try {
+        const keyPair = await programManager.synthesizeKeys(hello_hello_program, aleoFunction, inputs);
+
+        programManager.keyProvider.cacheKeys(`${programName}:${aleoFunction}`, keyPair);
+
+    } catch (e) {
+        throw new Error(`Failed to synthesize keys: ${e.message}`);
+    }
+
+    // Specify parameters for the key provider to use search for program keys. In particular specify the cache key
+    // that was used to cache the keys in the previous step.
+    const keyProviderParams = new AleoKeyProviderParams({cacheKey: `${programName}:${aleoFunction}`});
+
+    // Execute once using the key provider params defined above. This will use the cached proving keys and make
+    // execution significantly faster.
+    let executionResponse = await programManager.run(
+        program,
+        aleoFunction,
+        inputs,
+        true,
+        undefined,
+        keyProviderParams,
+    );
+    console.log("hello_hello/hello executed - result:", executionResponse.getOutputs());
+
+    // Verify the execution using the verifying key that was generated earlier.
+    if (programManager.verifyExecution(executionResponse)) {
+        console.log("hello_hello/hello execution verified!");
+    } else {
+        throw("Execution failed verification!");
+    }
+}
+
+const start = Date.now();
+console.log("Starting execute!");
+await localProgramExecution(hello_hello_program, programName, "hello", ["5u32", "5u32"]);
+console.log("Execute finished!", Date.now() - start);

package/template-node-ts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "target": "es2017",
+    "module": "esnext",
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+
+    /* Advanced Options */
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

package/template-offline-public-transaction-ts/README.md

@@ -0,0 +1,52 @@
+# Offline Transaction Builder 
+
+## 1. Overview
+### 1.1 Proving Keys for Zero Knowledge Function Execution
+To achieve zero knowledge execution, all Aleo functions require a `ProvingKey` and `VerifyingKey` in order to build a
+zero knowledge ZkSnark proof of execution. If a user does not possess these keys for a function, they are normally
+downloaded from the internet when the function is called.
+
+### 1.2 Key Providers
+They `KeyProvider` interface is designed to allow users to provide their own implementations for providing key material
+to Aleo function executions.
+
+### 1.3 Building Transactions Offline
+
+The `OfflineKeyProvider` enables Transaction Building without connection to the internet.
+
+The `OfflineKeyProvider` and `OfflineSearchParams` are concrete implementations of the `KeyProvider` and `KeySearchParams` 
+interfaces. They are designed to fetch proving key material for Aleo functions from a local machine instead of contacting
+the internet for it. This provides a way to build Aleo execution transactions without being connected to the internet.
+
+This pathway is suitable for use-cases such as hardware wallets or air-gapped machines used
+for building secure transactions.
+
+### 1.4 Assumptions
+
+The key material in this example is assumed to be pre-downloaded onto the machine performing the 
+construction of the offline transaction.
+
+## 2. Usage
+
+### 2.1 Pre-Download the Keys
+First run this command online to download the key material to disk:
+
+`npm start`
+
+Once this command is run, all proving keys for the `transfer_public`, `bond_public`, `unbond_public`, and
+`claim_unbond_public` functions will be downloaded to the `./keys` folder. The machine can then be disconnected from
+the internet and the `OfflineKeyProvider` will search this directory for the function proving keys when building the
+transaction instead of connecting to the internet. Alternatively you can skip the online step entirely by adding the proving key creating this directory manually and
+adding the key material yourself.
+
+### 2.2 Build the Transaction Offline
+
+Once the key material is downloaded, turn off your internet connection and run the following command:
+
+`npm start`
+
+You should see the transactions being built and the resulting transaction IDs printed to the console.
+
+## 3. Notes
+
+Node.js 20+ is recommended for best performance.

package/template-offline-public-transaction-ts/_gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

package/template-offline-public-transaction-ts/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "node-offline-transaction-example",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "build": "rimraf dist/js && rollup --config",
+    "dev": "npm run build && node dist/index.js"
+  },
+  "dependencies": {
+    "@provablehq/sdk": "^0.8.0"
+  },
+  "devDependencies": {
+    "rimraf": "^6.0.1",
+    "rollup": "^4.32.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "typescript": "^5.7.3"
+  }
+}

package/template-offline-public-transaction-ts/rollup.config.js

@@ -0,0 +1,19 @@
+import typescript from "rollup-plugin-typescript2";
+
+export default {
+    input: {
+        index: "./src/index.ts",
+    },
+    output: {
+        dir: `dist`,
+        format: "es",
+        sourcemap: true,
+    },
+    external: ['@provablehq/sdk'],
+    plugins: [
+        typescript({
+            tsconfig: "tsconfig.json",
+            clean: true,
+        }),
+    ],
+};

package/template-offline-public-transaction-ts/src/helpers.ts

@@ -0,0 +1,70 @@
+import { CREDITS_PROGRAM_KEYS } from "@provablehq/sdk";
+import { promises as fsPromises, writeFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+async function downloadAndSaveKey(keyData, keysDirPath) {
+    const locatorParts = keyData.locator.split('/');
+    const fileName = locatorParts.pop();
+    const dirPath = path.join(keysDirPath, ...locatorParts);
+    await fsPromises.mkdir(dirPath, { recursive: true });
+    const filePath = path.join(dirPath, `${fileName}.prover`);
+
+    try {
+        await fsPromises.access(filePath);
+        return filePath;
+    } catch {
+        const res = await fetch(keyData.prover);
+        const buffer = await res.arrayBuffer();
+        writeFileSync(filePath, new Uint8Array(buffer), { flag: 'wx' });
+        console.log(`Downloaded ${keyData.locator}.prover to ${filePath}`);
+        return filePath;
+    }
+}
+
+async function preDownloadTransferKeys() {
+    const keyPaths = {};
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const keysDirPath = path.join(__dirname, "keys");
+    await fsPromises.mkdir(keysDirPath, { recursive: true });
+
+    for (const keyData of [CREDITS_PROGRAM_KEYS.transfer_public, CREDITS_PROGRAM_KEYS.fee_public]) {
+        try {
+            keyPaths[keyData.locator] = await downloadAndSaveKey(keyData, keysDirPath);
+        } catch (error) {
+            throw(`Failed to download ${keyData.locator} - ${error}`);
+        }
+    }
+
+    return keyPaths;
+}
+
+async function preDownloadBondingKeys() {
+    const keyPaths = {};
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const keysDirPath = path.join(__dirname, "keys");
+    await fsPromises.mkdir(keysDirPath, { recursive: true });
+
+    for (const keyData of [CREDITS_PROGRAM_KEYS.bond_public, CREDITS_PROGRAM_KEYS.fee_public, CREDITS_PROGRAM_KEYS.unbond_public, CREDITS_PROGRAM_KEYS.claim_unbond_public]) {
+        try {
+            keyPaths[keyData.locator] = await downloadAndSaveKey(keyData, keysDirPath);
+        } catch (error) {
+            throw(`Failed to download ${keyData.locator} - ${error}`);
+        }
+    }
+
+    return keyPaths;
+}
+
+async function getLocalKey(filePath: string): Promise<Uint8Array> {
+    try {
+        console.log("Reading key file:", filePath);
+        const buffer = await fsPromises.readFile(filePath);
+        return new Uint8Array(buffer);
+    } catch (error) {
+        console.error("Error reading file:", error);
+        throw error;
+    }
+}
+
+export { downloadAndSaveKey, getLocalKey, preDownloadBondingKeys, preDownloadTransferKeys };

package/template-offline-public-transaction-ts/src/index.ts

@@ -0,0 +1,171 @@
+import {Account, Address, CREDITS_PROGRAM_KEYS, initThreadPool, ProgramManager, OfflineQuery, OfflineKeyProvider, OfflineSearchParams, ProvingKey, Transaction} from "@provablehq/sdk";
+import { getLocalKey, preDownloadBondingKeys, preDownloadTransferKeys } from "./helpers";
+
+await initThreadPool();
+
+/// Build transfer public transaction without connection to the internet
+async function buildTransferPublicTxOffline(recipientAddress: Address, amount: number, latestStateRoot: string, keyPaths: {}): Promise<Transaction>  {
+    // Create an offline program manager
+    const programManager = new ProgramManager();
+
+    // Create a temporary account for the execution of the program
+    const account = new Account();
+    programManager.setAccount(account);
+
+    // Create the proving keys from the key bytes on the offline machine
+    console.log("Creating proving keys from local key files");
+    const feePublicKeyBytes = await getLocalKey(<string>keyPaths[CREDITS_PROGRAM_KEYS.fee_public.locator]);
+    const transferPublicAsSignerKeyBytes = await getLocalKey(<string>keyPaths[CREDITS_PROGRAM_KEYS.transfer_public_as_signer.locator]);
+    const feePublicProvingKey = ProvingKey.fromBytes(feePublicKeyBytes);
+    const transferPublicProvingKey = ProvingKey.fromBytes(transferPublicAsSignerKeyBytes);
+
+    // Create an offline key provider
+    console.log("Creating offline key provider");
+    const offlineKeyProvider = new OfflineKeyProvider();
+
+    // Insert the proving keys into the offline key provider. The key provider will automatically insert the verifying
+    // keys into the key manager.
+    console.log("Inserting proving keys into key provider");
+    offlineKeyProvider.insertFeePublicKeys(feePublicProvingKey);
+    offlineKeyProvider.insertTransferPublicKeys(transferPublicProvingKey);
+
+    // Create an offline query to complete the inclusion proof
+    const offlineQuery = new OfflineQuery(latestStateRoot);
+
+    // Insert the key provider into the program manager
+    programManager.setKeyProvider(offlineKeyProvider);
+
+    // Build tne transfer_public transaction offline
+    console.log("Building transfer transaction offline");
+    return programManager.buildTransferPublicAsSignerTransaction(
+        amount,
+        recipientAddress.to_string(),
+        0.28,
+        undefined,
+        offlineQuery,
+    );
+}
+
+/// Build bonding and unbonding transactions without connection to the internet
+async function buildBondingTxOffline(stakerAddress: Address,  validatorAddress: Address, withdrawalAddress: Address, amount: number, latestStateRoot: string, keyPaths: {}): Promise<Transaction[]> {
+    // Create an offline program manager
+    const programManager = new ProgramManager();
+
+    // Create a temporary account for the execution of the program
+    const account = new Account();
+    programManager.setAccount(account);
+
+    // Create the proving keys from the key bytes on the offline machine
+    console.log("Creating proving keys from local key files");
+    const feePublicKeyBytes = await getLocalKey(<string>keyPaths[CREDITS_PROGRAM_KEYS.fee_public.locator]);
+    const bondPublicKeyBytes = await getLocalKey(<string>keyPaths[CREDITS_PROGRAM_KEYS.bond_public.locator]);
+    const unbondPublicKeyBytes = await getLocalKey(<string>keyPaths[CREDITS_PROGRAM_KEYS.unbond_public.locator]);
+    const claimUnbondPublicKeyBytes = await getLocalKey(<string>keyPaths[CREDITS_PROGRAM_KEYS.claim_unbond_public.locator]);
+    const feePublicProvingKey = ProvingKey.fromBytes(feePublicKeyBytes);
+    const bondPublicProvingKey = ProvingKey.fromBytes(bondPublicKeyBytes);
+    const unBondPublicProvingKey = ProvingKey.fromBytes(unbondPublicKeyBytes);
+    const claimUnbondPublicProvingKey = ProvingKey.fromBytes(claimUnbondPublicKeyBytes);
+
+    // Create an offline key provider to fetch keys without connection to the internet
+    console.log("Creating offline key provider");
+    const offlineKeyProvider = new OfflineKeyProvider();
+
+    // Insert the proving keys into the offline key provider. The key provider will automatically insert the verifying
+    // keys into the key manager.
+    console.log("Inserting proving keys into key provider");
+    offlineKeyProvider.insertFeePublicKeys(feePublicProvingKey);
+    offlineKeyProvider.insertBondPublicKeys(bondPublicProvingKey);
+    offlineKeyProvider.insertUnbondPublicKeys(unBondPublicProvingKey);
+    offlineKeyProvider.insertClaimUnbondPublicKeys(claimUnbondPublicProvingKey);
+
+    // Insert the key provider into the program manager
+    programManager.setKeyProvider(offlineKeyProvider);
+
+    // Build the bonding transactions offline
+    console.log("Building a bond_public execution transaction offline");
+    const bondPublicOptions = {
+        executionParams: {
+            keySearchParams: OfflineSearchParams.bondPublicKeyParams()
+        },
+        offlineParams: {
+            offlineQuery: new OfflineQuery(latestStateRoot)
+        }
+    }
+
+    const bondTx = <Transaction>await programManager.buildBondPublicTransaction(
+        stakerAddress.to_string(),
+        validatorAddress.to_string(),
+        withdrawalAddress.to_string(),
+        amount,
+        bondPublicOptions,
+    )
+    console.log("\nbond_public transaction built!\n");
+
+    console.log("Building an unbond_public execution transaction offline")
+    const unbondPublicOptions = {
+        executionParams: {
+            keySearchParams: OfflineSearchParams.unbondPublicKeyParams()
+        },
+        offlineParams: {
+            offlineQuery: new OfflineQuery(latestStateRoot)
+        }
+    }
+
+    const unBondTx = <Transaction>await programManager.buildUnbondPublicTransaction(stakerAddress.to_string(), amount, unbondPublicOptions);
+    console.log("\nunbond_public transaction built!\n");
+
+    console.log("Building a claim_unbond_public transaction offline")
+    // Build the claim unbonding transaction offline
+    const claimUnbondPublicOptions = {
+        executionParams: {
+            keySearchParams: OfflineSearchParams.claimUnbondPublicKeyParams()
+        },
+        offlineParams: {
+            offlineQuery: new OfflineQuery(latestStateRoot)
+        }
+    }
+
+    const claimUnbondTx = <Transaction>await programManager.buildClaimUnbondPublicTransaction(stakerAddress.to_string(), claimUnbondPublicOptions);
+    console.log("\nclaim_unbond_public transaction built!\n");
+    return [bondTx, unBondTx, claimUnbondTx];
+}
+
+// -------------------ONLINE COMPONENT---------------------
+//     (Do this part on an internet connected machine)
+
+// Download the needed keys for the functions we want to execute offline
+const transferKeyPaths = await preDownloadTransferKeys();
+const bondingKeyPaths = await preDownloadBondingKeys();
+//---------------------------------------------------------
+
+// ------------------OFFLINE COMPONENT---------------------
+//           (Do this part on an offline machine)
+// Get the latest state root from an online machine and enter it into an offline machine
+const latestStateRoot = "sr1p93gpsezrjzdhcd2wujznx5s07k8qa39t6vfcej35zew8vn2jyrs46te8q";
+
+// Build a transfer_public transaction
+const stakerAddress = new Account().address();
+const validatorAddress = new Account().address();
+const withdrawalAddress = new Account().address();
+const transferTx = await buildTransferPublicTxOffline(stakerAddress, 10000, latestStateRoot, transferKeyPaths);
+console.log("Transfer transaction built offline!");
+console.log(`\n---------------transfer_public transaction---------------\n${transferTx}`);
+console.log(`---------------------------------------------------------`);
+
+// Build bonding & unbonding transactions
+const bondTransactions = await buildBondingTxOffline(stakerAddress, validatorAddress, withdrawalAddress, 100, latestStateRoot, bondingKeyPaths);
+console.log("Bonding transactions built offline!");
+console.log(`\n-----------------bond_public transaction-----------------\n${bondTransactions[0]}`);
+console.log(`---------------------------------------------------------`);
+console.log(`\n----------------unbond_public transaction:---------------\n${bondTransactions[1]}`);
+console.log(`---------------------------------------------------------`);
+console.log(`\n-----------------claim_unbond transaction:---------------\n${bondTransactions[2]}`);
+console.log(`---------------------------------------------------------`);
+//---------------------------------------------------------
+
+// -------------------ONLINE COMPONENT---------------------
+//     (Do this part on an internet connected machine)
+// ONLINE COMPONENT (Uncomment this part to send the transaction to the Aleo Network on an internet connected machine)
+// Submit the transaction to the network
+// const transferTxId = await networkClient.submitTransaction(transferTx);
+//---------------------------------------------------------

package/template-offline-public-transaction-ts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "target": "es2017",
+    "module": "esnext",
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+
+    /* Advanced Options */
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

package/template-react-leo/.babelrc

@@ -0,0 +1,6 @@
+{
+    "presets": [
+        "@babel/preset-env",
+        ["@babel/preset-react", { "runtime": "automatic" }]
+    ]
+}

package/template-react-leo/.eslintrc.cjs

@@ -0,0 +1,20 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    'eslint:recommended',
+    'plugin:react/recommended',
+    'plugin:react/jsx-runtime',
+    'plugin:react-hooks/recommended',
+  ],
+  ignorePatterns: ['dist', '.eslintrc.cjs'],
+  parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+  settings: { react: { version: '18.2' } },
+  plugins: ['react-refresh'],
+  rules: {
+    'react-refresh/only-export-components': [
+      'warn',
+      { allowConstantExport: true },
+    ],
+  },
+}

package/template-react-leo/README.md

@@ -0,0 +1,85 @@
+# React + Aleo + Leo
+
+[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/fork/github/ProvableHQ/sdk/tree/mainnet/create-leo-app/template-react-leo)
+
+This template provides a minimal setup to get React and Aleo working in Webpack or Vite with HMR and some ESLint rules.
+
+This template includes a Leo program that is loaded by the web app located in
+the `helloworld` directory.
+
+### Start in development mode
+
+```bash
+npm run dev
+```
+
+Your app should be running on http://localhost:5173/
+
+### Build Leo program
+
+1. Copy the `helloworld/.env.example` to `helloworld/.env` (this will be ignored
+   by Git):
+
+   ```bash
+   cd helloworld
+   cp .env.example .env
+   ```
+
+2. Replace `PRIVATE_KEY=user1PrivateKey` in the `.env` with your own key (you
+   can use an existing one or generate your own at https://provable.tools/account)
+
+3. Follow instructions to install Leo here: https://github.com/ProvableHQ/leo
+
+4. You can edit `helloworld/src/main.leo` and run `leo run` to compile and update the
+   Aleo instructions under `build` which are loaded by the web app.
+
+## Deploy program from web app
+
+> [!WARNING]
+> This is for demonstration purposes or local testing only, in production applications you
+> should avoid building a public facing web app with private key information
+
+Information on generating a private key, seeding a wallet with funds, and finding a spendable record can be found here
+if you are unfamiliar: https://docs.leo-lang.org/testnet/getting_started/deploy_execute_demo
+
+Aleo programs deployed require unique names, make sure to edit the program's name to something unique in `helloworld/src/main.leo`, `helloworld/program.json`, rename `helloworld/inputs/helloworld.in` and rebuild.
+
+1. In the `worker.js` file modify the privateKey to be an account with available
+   funds
+
+   ```js
+   // Use existing account with funds
+   const account = new Account({
+     privateKey: "user1PrivateKey",
+   });
+   ```
+
+2. (Optional) Provide a fee record manually (located in commented code within `worker.js`)
+
+   If you do not provide a manual fee record, the SDK will attempt to scan for a record starting at the latest block. A simple way to speed this up would be to make a public transaction to this account right before deploying.
+
+3. Run the web app and hit the deploy button
+
+## Production deployment
+
+### Build
+
+`npm run build`
+
+Upload `dist` folder to your host of choice.
+
+### ⚠️ Header warnings
+
+`DOMException: Failed to execute 'postMessage' on 'Worker': SharedArrayBuffer transfer requires self.crossOriginIsolated`
+
+If you get a warning similar to this when deploying your application, you need
+to make sure your web server is configured with the following headers:
+
+```
+Cross-Origin-Opener-Policy: same-origin
+Cross-Origin-Embedder-Policy: require-corp
+```
+
+We've included a `_headers` file that works with some web hosts (e.g. Netlify)
+but depending on your host / server setup you may need to configure the headers
+manually.

package/template-react-leo/_gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

package/template-react-leo/_headers

@@ -0,0 +1,3 @@
+/*
+  Cross-Origin-Opener-Policy: same-origin
+  Cross-Origin-Embedder-Policy: require-corp

package/template-react-leo/helloworld/.env.example

@@ -0,0 +1,2 @@
+NETWORK=testnet
+PRIVATE_KEY=user1PrivateKey